LogoLogo
  • INTRODUCTION
  • LEARN
    • Espresso in the Modular Stack
    • The Espresso Network
      • System Overview
      • Properties of HotShot
        • EspressoDA
          • How It Works
      • Interfaces
        • Espresso ↔ Rollup
        • Espresso ↔ L1
        • Rollup ↔ L1
      • Internal Functionality
        • Espresso Node
        • Light Client Contract
        • Fee Token Contract
        • Stake Table
          • How the Stake Table Contract Works
        • Smart Contract Upgradeability
    • Rollup Stacks
      • Integrating a ZK Rollup
        • ZK Rollup Architecture
        • Using Espresso
        • Summary of Changes
      • Integrating an Optimistic Rollup
        • Optimistic Rollup Architecture
        • Using Espresso
        • Summary of Changes
  • Guides
    • Using the Espresso Network
      • Integrating Arbitrum Orbit Chain
        • Quickstart with Arbitrum Nitro Rollups
        • Reading Confirmations from the Espresso Network
        • Arbitrum Nitro Integration Overview
          • Using TEE with Nitro
          • Arbitrum Nitro Trust & Liveness Dependencies
        • Migrating Arbitrum Orbit Chains to Espresso
          • Arbitrum Testnet
            • Nitro Testnet
            • Local Deployment (`docker compose`)
      • Using the Espresso Network as a Cartesi application
    • Running an Espresso Node
    • Running a Builder
    • Bridging with the Espresso Network
  • API Reference
    • Espresso API
      • Status API
      • Catchup API
      • Availability API
      • Node API
      • State API
      • Events API
      • Submit API
      • Earlier Versions
        • v0
          • Status API
          • Catchup API
          • Availability API
          • Node API
          • State API
          • Events API
          • Submit API
    • Builder API
  • Releases
    • Mainnet 1
      • Running a Mainnet 1 Node
      • Contracts
      • Rollup Migration Guide
    • Mainnet 0
      • Running a Mainnet 0 Node
      • Contracts
    • Testnets
      • Decaf Testnet Release
        • Running a Node
        • Contracts
      • Cappuccino Testnet Release
        • Running a Node
        • Deploying a Rollup on Cappuccino
        • Benchmarks
      • Gibraltar Testnet Release
        • Interacting with Gibraltar
        • Arbitrum Nitro integration
        • Deploying a Rollup on Gibraltar
      • Cortado Testnet Release
        • Interacting with Cortado
        • OP Stack Integration
          • Optimism Leader Election RFP
      • Doppio Testnet Release
        • Interacting with Doppio
        • Polygon zkEVM Stack Integration
        • Minimal Rollup Example
        • Benchmarks
      • Americano Testnet Release
  • Appendix
    • Interacting with L1
      • Trustless Sync
      • Fork Recovery
      • Bridging
    • Glossary of Key Terms
Powered by GitBook
On this page
  1. Appendix
  2. Interacting with L1

Trustless Sync

PreviousInteracting with L1NextFork Recovery

Last updated 1 year ago

One of the main reasons to use blockchains is to decentralize trust. However, the current Ethereum ecosystem often compromises on this principle by using trusted query services like for clients to access the blockchain. This trades off trustlessness for convenience and scalability, since a client that trusts a query service does not need to verify any Ethereum block data.

However, Ethereum's switch to proof-of-stake and its rollup-centric roadmap offer the potential to break out of this tradeoff, enabling efficient and user-friendly clients that retain decentralized trust. When rollups post their state updates to Ethereum or a similar L1, each L1 validator independently validates the state transition for the rollup by executing the rollup's smart contract. This means that any user who trusts the collective L1 validator set can quickly sync with the latest state of the rollup simply by reading a recent, verified state update from the L1 state.

Of course, this only pushes the problem of fast, trustless sync to the L1. This is nonetheless a substantial improvement. In the case of Ethereum, the proof-of-stake consensus protocol and the fixed block time enable the creation of L1 light clients which sync far faster than real time. For instance, is an Ethereum light client which manages trustless sync in only 2 seconds. By verifying HotShot and rollup states on Ethereum, any such Ethereum client can be turned into a client for any rollup merely by syncing with Ethereum and then reading rollup state from the appropriate smart contract.

Infura
Helios