Eclipse Documentation
HomeBridge
  • 🐮Users
    • Getting Started
      • 1. Set Up Your Eclipse Wallet
      • 2. Bridge Assets for Gas and Transactions
      • 3. Explore the Eclipse Ecosystem
      • 4. Engage with the Community on Discord
    • User Resources
    • Unified Restaking Tokens (URTs)
    • Yield From Real World Treasury Bills
  • 🛠️Developers
    • Getting Started
    • Wallet
      • Mainnet Wallets
      • Testnet & Devnet Wallets
        • Adding Eclipse Wallet to dApp
        • Custom Wallets
    • RPC & Block Explorers
      • Dragon's Mouth gRPC Subscriptions
    • Bridges
      • Eclipse Canonical Bridge
      • Hyperlane
    • Oracles
      • Pyth Network
      • Switchboard
    • NFTs
      • Metaplex
      • Nifty Asset
      • Libreplex (Token-2022)
    • Developer Tooling
      • Faucet
      • Benchmarking
        • Running AMM benchmarking tests
      • Decentralized Identities
        • AllDomains
      • OpenBook Quickstart
      • Multisig
    • Eclipse Bug Bounty Program
    • Eclipse Status Page
    • Frequently Asked Questions
    • Differences Between Eclipse and Solana
    • Eclipse Program Registry Guide
  • 📖Tutorials & Guides
    • Developer Guides
      • Quick Start: "Hello World"
        • Deployment Walkthrough
      • Reading from the blockchain
      • Modifying a Solana dApp to Support Eclipse: "Chomping Glass"
        • Developing on the Solana Virtual Machine (SVM)
        • Multi-chain toggle frontend component
      • Dapp Deployment Tutorial - Eclipse Devnet
        • ⚙️Install Dependencies - Windows
          • Step 1: Install Visual Studio Code (VSC)
          • Step 2: Install Rust and Cargo
          • Step 3: Download Visual Studio C++ Build Tools
          • Step 4: Download Node.js
          • Step 5: Install Git on Windows
          • Step 6: Install the Solana CLI
          • Step 7: Install WSL on Visual Studio Code and Upgrade to WSL2
          • Step 8: Set Up Development Environment in Ubuntu WSL
          • Step 9: Install Anchor on Windows and WSL
        • 🏝️Solana CLI & Solana Keypair
          • Step 1: Set Solana CLI to Use Eclipse Devnet
          • Step 2: Verify Solana CLI Configuration
          • Step 3: Generate a New Solana Keypair
          • Step 4: Claim Devnet ETH for Transaction Fees
          • Optional Step: View Balance on Devnet Explorer
        • 🖥️Creating an Anchor Project in Visual Studio Code
          • Step 1: Initialize Anchor Project
          • Step 2: Update the lib.rs File with Smart Contract Code
          • Step 3: Update the Smart Contract's Cargo.toml File
          • Step 4: Update the Project's Root Cargo.toml File
          • Step 5: Compile Your Program with anchor build
          • Step 6: Deploy Your Project to the Eclipse Devnet
          • Step 7: Verify Program Deployment on the Eclipse Devnet Explorer
        • ✨Building a React App Front-End
          • Step 1: Create a New React Project with TypeScript
          • Step 2: Install Solana Web3.js and Wallet Adapter Dependencies
          • Step 3: Install Additional Dependencies for Enhanced Functionality and Compatibility
          • Step 4: Configure Webpack for Browser Compatibility
          • Step 5: Start the Development Server and Verify Setup
          • Step 6: Implement the UI for Your NFT Minter in App.tsx with Updated Code
      • Eclipse Testnet ETH Transfer Transaction Fee Estimator
        • Program Breakdown
        • Program JSX & CSS
        • Program Execution
      • Pyth: How to Use Real-Time Data in Solana Programs
      • Quick Start: User Guide - Testnet
      • cNFTs on Eclipse
        • Create 1 Million NFTs on Eclipse
        • How to Interact with cNFTs
  • 🧠Eclipse Architecture
    • What is Eclipse Mainnet?
      • Settlement - Ethereum
      • Execution - Solana Virtual Machine (SVM)
      • Data Availability - Celestia
      • Proving - RISC Zero
      • Why Eclipse, Why Ethereum, Why Now
    • Lifecycle of an Eclipse Transaction
  • 📚Additional Resources
    • External Documentation
    • Disclosures
Powered by GitBook
On this page
  • 1. Creating a Transaction
  • 2. Sequencing Transactions
  • 3. Producing a Block
  • 4. Settling a Transaction
  • Optimistic Settlement
Edit on GitHub
  1. Eclipse Architecture

Lifecycle of an Eclipse Transaction

It's easier to understand the components of the Eclipse Mainnet from the perspective of a transaction.

PreviousWhy Eclipse, Why Ethereum, Why NowNextExternal Documentation

Last updated 8 days ago

1. Creating a Transaction

As with all chains, users typically start interacting with Eclipse via some dApp. The dApp proposes a transaction for the user to sign with their wallet, and the signed transaction is sent to an RPC node.

RPC nodes implement different APIs depending on the blockchain. For example, EVM chains typically implement the JSON-RPC whereas VM (SVM) chains have their own JSON-RPC specification.

Eclipse Mainnet implements the SVM JSON-RPC. SVM wallets can send transactions straight to Eclipse full nodes.

2. Sequencing Transactions

Once a transaction is received, it must be ordered relative to other transactions. This ordering is important because searchers can capture arbitrage opportunities (miner extractable value or MEV) based on how the transactions are ordered. This job is left to the logical entity known as the sequencer.

There are different approaches to sequencing transactions. The simplest approach, which most rollups have implemented at this point, is a centralized sequencer. More sophisticated approaches involve shared sequencers, where the same sequencer is ordering transactions for multiple chains, and decentralized sequencers, where a consensus mechanism is typically inserted into a set of sequencers for a single chain.

3. Producing a Block

Once transactions are ordered, a commitment is made to the sequence of transactions and the sequence is fed into an executor. This is the executor responsible for computing the resulting state of the blockchain. Remember that blockchains are really just state transition functions:

s′=f(s,t)s' = f(s, t)s′=f(s,t)

Transactions are received, they are executed, and now we have the resulting (untrusted) state root along with a block of transactions. State root commitments are cryptographic commitments to the state of a blockchain after a set of transactions has been executed. The tricky part is that Eclipse Mainnet doesn't compute a global state root, as this would force a sequential bottleneck. Instead, a commitment is made of the "state diff".

Eclipse block production is primarily managed by the sequencer, which helps the network by providing the following services:

  • Providing transaction confirmations and state updates

  • Constructing and executing rollup blocks

  • Posting rollup blocks to the data availability layer

For the moment, the Eclipse team runs the only block producer(s). Refer to the Eclipse documentation for more information on how we plan to decentralize the sequencer role in the future.

4. Settling a Transaction

All rollups must somehow ensure that the computed state is correct. This is called the settlement process. The settlement process varies depending on whether you're running an optimistic or zero-knowledge rollup.

Optimistic Settlement

The commitment posted to Celestia is relayed to Ethereum. This allows verifiers to challenge the computed state.

If there are no challenges after the challenge period, then the transaction is finalized, meaning that the bridge will not roll back the commitment.

A full node is a node that executes all transactions within a block. (Clearly, executors in the section above are examples of full nodes.) Verifiers are full nodes that pull blocks of transactions from the data availability layer and re-execute them. Verifiers compare their computed commitment against the commitment posted to Ethereum and raise a challenge if there is a discrepancy. Verifiers can raise challenges during a window of time known as the challenge period. This challenge utilizes our .

🧠
zk-VM
Ethereum
Solana
The Eclipse stack can be visually represented as "layers."