Modular Components of Eclipse
Settlement: Ethereum
Ethereum serves as the trust anchor for Eclipse. All finalized state transitions on Eclipse are rooted to Ethereum, ensuring:
Economic finality based on Ethereum's validator set.
Robust fraud proofs and escape hatches to protect users.
Censorship resistance independent of Eclipse validators.
By outsourcing security to Ethereum, Eclipse validators can focus entirely on maximizing throughput, latency, and computational efficiency.
Execution: GSVM: Eclipse's Next Generation SVM Client
Eclipse extends the Solana Virtual Machine (SVM) with GSVM, a high-performance, hardware-aware implementation.
GSVM leverages SmartNICs and FPGAs to offload cryptographic verification, transaction filtering, and pre-processing. Combined with NVMe-backed, state-optimized storage formats, this minimizes latency and maximizes compute efficiency. The compute pipeline is optimized for multi-core CPUs and GPU-accelerated tasks, integrating tightly with a storage engine that aligns with modern I/O patterns.
Execution, storage, and networking operate in a tightly optimized loop. Sequencers can hint storage to prefetch state before execution, reducing I/O stalls and increasing pipeline utilization.
GSVM introduces the concept of Hotspot Islands, isolated execution zones for high-traffic workloads like AMMs or games. Each island has local fee markets and dedicated compute threads, ensuring that congestion is contained and global throughput isn't compromised.
The diagram above illustrates how the GSVM client isolates applications into dedicated execution zones, minimizing interference and maximizing throughput.
Concurrency control is hybrid: optimistic paths reduce unnecessary serialization, while pessimistic fallback ensures correctness for contentious interactions. Over time, GSVM becomes smarter, profile-guided and reinforcement-learned optimizations adapt to application behavior, improving resource scheduling and hotspot management.
Data Availability: Celestia
Eclipse uses Celestia as its modular DA layer. The Eclipse Celestia Publisher system ensures scalable, fault-tolerant publishing of transaction data through three coordinated stages.
The publisher retrieves finalized Eclipse blocks, batches and compresses them, and submits them to Celestia as data blobs. These blobs are then erasure-coded and included in a Merkle root by Celestia validators. A separate gateway module aggregates published batches, computes their commitment root, and anchors that root to Ethereum for verifiability.
The diagram above gives a high-level view of how data flows through the publishing pipeline, from Eclipse block production to Ethereum anchoring.
Above is a more detailed view of the interactions between system components and actors involved in this process:
How Celestia Data Availability Works
When Eclipse blocks are submitted to Celestia, the Celestia DA layer erasure-codes the data and embeds it into namespaced Merkle trees. Light clients perform data availability sampling by randomly selecting shares of each blob to verify availability. If enough of these shares are present, clients can probabilistically assume that the entire dataset is retrievable. This provides scalable assurance without requiring full node replication.
Data Flow of the Publisher
The publishing process is split across three stages:
Block Indexing: Eclipse blocks are continuously fetched and indexed with metadata.
Publishing to Celestia: Indexed blocks are batched and compressed into Celestia blobs. Commitments and block heights are stored.
Ethereum Anchoring: The Gateway aggregates commitments, computes a Merkle root, and submits it to an Ethereum smart contract.
This system allows Eclipse to offload massive data throughput while maintaining verifiability and settlement integrity.
Proving: RISC Zero
Eclipse employs RISC Zero for fraud proof generation, providing:
Succinct, verifiable fraud proofs using zero-knowledge techniques.
Protection against invalid state transitions.
Minimal performance overhead during normal operation.
As an optimistic rollup, Eclipse assumes honest execution but enforces verifiability and accountability through RISC Zero's zkVM.
Last updated
Was this helpful?