# Eclipse and Celestia: Redefining Data Availability for High-Throughput Blockchains

*Layer 2 (L2) networks like Eclipse rely on robust data availability (DA) mechanisms to ensure users can reconstruct and verify the chain’s state. While Ethereum’s EIP-4844 simplifies DA proofs for rollups, Eclipse’s use of Celestia as its DA layer introduces unique challenges and innovations. This article explores how Eclipse leverages Celestia’s Blobstream and cutting-edge cryptography to achieve scalability without compromising security.*

By [0xshaadab](https://paragraph.com/@0xshaadab) · 2025-05-09

#eclipse, #modular#, celestia

---

### **The DA Bridging Challenge**

1.  **Ethereum vs. Celestia**:
    
    *   Ethereum’s EIP-4844 allows rollups to verify blob existence directly via smart contracts.
        
    *   Celestia lacks native Ethereum compatibility, requiring **DA bridging** to prove data availability.
        
2.  **Blobstream**:
    
    *   Celestia’s DA bridging protocol, implemented via **RISC Zero** and **Succinct**, uses a relayer to:
        
        *   Generate ZK proofs confirming Celestia blocks are valid.
            
        *   Build a Merkle tree of block data roots (the **data root tuple root**).
            
        *   Store this root in an Ethereum smart contract for on-chain verification.
            

### **Celestia’s Merkle Tree Architecture**

1.  **Extended Data Square (EDS)**:
    
    *   Celestia splits data into **shares** (512-byte units) arranged in a matrix.
        
    *   **Erasure coding** ensures data recovery even if some shares are lost.
        
2.  **Nested Commitments**:
    
    *   **Namespaced Merkle Trees (NMTs)**: Organize shares by application (e.g., Eclipse’s namespace).
        
    *   **Row/Column Roots**: Each row and column of the EDS has its own Merkle root.
        
    *   **Block Data Root**: Aggregates all roots into a single commitment.
        

### **Proving Data Availability**

Eclipse uses two methods to verify data existence on Celestia:

#### **1\. Sequence of Spans**

*   **Mechanism**: Identifies blobs by their position in the EDS.
    
*   **Advantages**:
    
    *   **Symmetry**: Inclusion/exclusion proofs are equally simple (checking share boundaries).
        
    *   **No Data Download**: Reduces verification costs.
        

#### **2\. Blob Share Commitment**

*   **Mechanism**: Uses a hash to verify blob content.
    
*   **Challenges**:
    
    *   **Exclusion Proofs**: Require checking all "Pay For Blob" (PFB) transactions, which is computationally intensive.
        
    *   **Cost**: Verification scales with blob size.
        

**Verdict**: Eclipse prioritizes **sequence of spans** for its simplicity and cost-efficiency in optimistic rollups.

### **Optimizing for Scale: Index Blobs and ZK Proofs**

1.  **Index Blobs**:
    
    *   **Problem**: Posting 500+ individual blobs to Ethereum is gas-prohibitive.
        
    *   **Solution**: A single **index blob** stores metadata (spans) for all blobs in a batch.
        
    *   **Impact**: Reduces Ethereum calldata costs by 99%, enabling **1M+ TPS**.
        
2.  **Steel (RISC Zero)**:
    
    *   **Function**: Generates ZK proofs off-chain to verify multiple Blobstream attestations.
        
    *   **Benefits**:
        
        *   Replaces 45M gas with a single 300k gas proof.
            
        *   Eliminates throughput limits imposed by Ethereum’s block gas.
            

### **Future-Proofing Scalability**

1.  **Celestia’s 1 GB Blocks**:
    
    *   Will enable Eclipse to process **30M+ TPS**, aligning with its **GigaCompute** vision.
        
2.  **Decentralized Proving (Bonsai/Boundless)**:
    
    *   RISC Zero’s networks will automate ZK proof generation, minimizing developer overhead.
        

### **Conclusion**

Eclipse’s integration of **Celestia Blobstream**, **index blobs**, and **ZK proofs** redefines blockchain scalability. By decoupling data availability from Ethereum’s constraints, Eclipse achieves:

*   **Cost Efficiency**: Near-zero on-chain fees via ZK optimizations.
    
*   **Security**: Celestia’s erasure coding and Merkle proofs ensure data integrity.
    
*   **Scalability**: A clear path to 30M+ TPS.
    

This modular approach positions Eclipse as a leader in high-performance L2 solutions, bridging the gap between decentralized security and enterprise-scale throughput.

SOURCES:  

**Eclipse Project References & Architecture**

[https://help.eclipse.org/latest/topic/org.eclipse.cdt.doc.user/tasks/cdt\_t\_proj\_referenced\_configs.htm](https://help.eclipse.org/latest/topic/org.eclipse.cdt.doc.user/tasks/cdt_t_proj_referenced_configs.htm)  
[https://projects.eclipse.org/projects/tools.datatools](https://projects.eclipse.org/projects/tools.datatools)  
[https://eclipse.dev/pdt/help/html/project\_references\_properties.htm](https://eclipse.dev/pdt/help/html/project_references_properties.htm)  
[https://eclipse.dev/eclipselink/documentation/2.7/concepts/data\_access002.htm](https://eclipse.dev/eclipselink/documentation/2.7/concepts/data_access002.htm)  
[https://github.com/eclipse](https://github.com/eclipse)  
[https://eclipsesource.com/](https://eclipsesource.com/)  
[https://projects.eclipse.org](https://projects.eclipse.org)  
[https://forum.processing.org/two/discussion/12673/include-the-files-from-the-data-directory-in-eclipse-and-have-it-working-in-exports.html](https://forum.processing.org/two/discussion/12673/include-the-files-from-the-data-directory-in-eclipse-and-have-it-working-in-exports.html)

---

*Originally published on [0xshaadab](https://paragraph.com/@0xshaadab/eclipse-and-celestia-redefining-data-availability-for-high-throughput-blockchains)*