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
  • Integration Architecture Walkthrough
  • Code Repository
  1. Releases
  2. Testnets
  3. Doppio Testnet Release

Polygon zkEVM Stack Integration

Proof-of-concept integration with Polygon zkEVM stack

PreviousInteracting with DoppioNextMinimal Rollup Example

Last updated 1 year ago

Espresso Systems has created a proof-of-concept integration with the Polygon zkEVM stack in Espresso. This integration highlights Espresso Systems’ vision of connecting and decentralizing rollups without compromising the scale and speed that rollup users have grown accustomed to.

The consists of two instances of the Polygon zkEVM using Espresso for decentralized sequencing and data availability in tandem. The following section is a brief walkthrough of both the technical architecture and the end-user experience for the integration.

Integration Architecture Walkthrough

The transaction flow through Polygon zkEVM-Espresso integration is as follows:

  • The user submits transaction to Polygon JSON-RPC interface.

  • The EVM transaction is sent to the L2 adapter and then sent to Espresso's submission API.

  • HotShot generates a block that includes the transaction.

  • The HotShot commitment service sends the batch commitment and quorum certificate to the L1 HotShot contract, which verifies that quorum certificate is valid and emits the event that a new quorum certificate has been posted.

  • The Synchronizer component of the zkEVM node gets the event via Etherman and queries the HotShot query service to obtain the full data for the batch (including the submitted transaction).

  • The zkEVM node computes the proof.

  • The proof is posted through Etherman library to the Polygon rollup contract.

  • The rollup contract verifies the proof and that the transactions are sequenced by HotShot (not yet implemented in Doppio).

Code Repository

The transaction is wrapped in a HotShot transaction and propagated to the .

The transaction is available to the .

The code for the Polygon zkEVM integration proof-of-concept can be found on GitHub: .

HotShot network
HotShot query service
espresso-polygon-zkevm-demo
integration demo
Diagram of the zkEVM integration