Polygon 2.0: Protocol Vision and Architecture

Author: Polygon Compilation: vernacular blockchain

Today, the engineering team at Polygon Labs is sharing the proposed architecture of Polygon 2.0, which aims to provide infinite scalability and unified liquidity, and realize the vision of Polygon as the value layer of the Internet.

Throughout its history, Web3 has faced thorny scaling problems. While it is possible to keep adding new chains to meet the demand for block space, this inevitably comes at a price: liquidity fragmentation and poor user experience.

Polygon 2.0 is the solution. Just as the Internet is an elastically scalable and unified information access environment, Polygon 2.0 is also an elastically scalable and unified value access environment: the value layer of the Internet.

We believe this proposal can and should guide all Polygon protocol development efforts moving forward, both as a conceptual north star and as a formal development framework.

Background: divergence and convergence

Since Polygon's inception, its developers and community have embraced the spirit of experimentation. Instead of trying to predict the future and betting on a single approach, we actively encourage multiple approaches to building the next generation of blockchain infrastructure. This is consistent with the typical process of creative problem solving, in which a divergent phase of exploring many ideas and approaches is followed by a convergent phase, in which these ideas and approaches consolidate and produce a solution to a problem. Given that blockchain is a young and very dynamic industry, this approach was an obvious choice.

During the initial divergence phase, the Polygon development team experimented across the technology stack. Just to name some of these efforts:

• Various blockchain architectures: sidechains, rollups, validiums, etc.;
• Various methods of building an execution environment supported by ZK: zkEVM types 1-3, Polygon Miden;
• Multiple blockchain clients: Polygon Edge, existing Ethereum clients, and custom clients such as the one currently used by Polygon zkEVM rollup;
• Various solutions for other parts of the stack, such as cross-chain messaging, staking, etc.

This stage is very useful. Various approaches and techniques were tried and many important lessons were learned. Time to start filtering and integrating ideas and efforts.

During the convergence phase, the Polygon protocol team and contributors gradually aligned on a specific protocol architecture (i.e. technology stack), which we are now happy to use as the optimal infrastructure for the Internet's value layer.

Protocol Architecture

The Polygon 2.0 architecture is formalized as a collection of protocol layers designed to function together. Perhaps the most prominent example of this layered architecture is the Internet Protocol Suite, whose four layers (Link, Network, Transport, and Application) power the Internet. Each protocol layer has a specific sub-process, and this logical separation simplifies reasoning, implementation, and upgrades of the architecture.

Polygon 2.0 consists of four protocol layers, each supporting an important process within the network:

• Pledge layer
• Interoperability layer
• Execution layer
• Verification layer

Pledge layer

The pledge layer is a PoS (Proof of Stake) based protocol that leverages Polygon's native token to provide decentralization to participating Polygon chains. It does this through a common, highly decentralized pool of validators and a built-in re-staking model.

The pledge layer is implemented on Ethereum through two types of smart contracts:

Validator Manager: The Validator Manager is a smart contract that manages a public pool of validators that all Polygon chains can utilize. It does the following:

• Maintain the registration of verifiers;
• Handle staking and unstaking requests from validators;
• Allow validators to subscribe, that is, to re-mortgage any number of Polygon chains;
• Handle cut events.

Chain Manager: The Chain Manager contract manages the set of validators for each Polygon chain. Each Polygon chain has its Chain Manager contract, which performs the following functions:

• Define the desired level of decentralization, i.e. the number of validators;
• (Optional) Define additional requirements for validators (e.g. GDPR compliance, holding other tokens in addition to Polygon's native token, etc.);
• (Optional) Define the slashing criteria.

As mentioned above, the Stake Layer provides decentralization of Polygon chains "out of the box", thereby enabling the teams of these chains to focus on use cases and communities rather than infrastructure. For validators, it offers guaranteed rewards in Polygon tokens, as well as the opportunity to receive additional income streams by collecting transaction fees and additional token rewards from the chains they validate.

Interoperability layer

The interoperability layer facilitates secure and seamless cross-chain messaging within the Polygon ecosystem. It abstracts the complexity of cross-chain communication and makes the entire Polygon network look like a chain to users, by enabling:

• Shared access to native Ethereum assets: Cross-chain bridges often require users to mint synthetic versions of Ethereum tokens - a user experience nightmare. The interoperability layer provides a shared bridge to Ethereum and allows seamless cross-chain transfer of native Ethereum assets.
• Seamless composability: The interoperability layer can support near-instant atomic cross-chain transactions, which is a core part of Polygon 2.0's unified liquidity vision.

The interoperability layer extends the design of the LxLy protocol currently used by Polygon zkEVM rollup and its concept of message queues. Each Polygon chain maintains a local outbound message queue in a predefined format containing: message (digital asset, i.e. token or arbitrary message), destination chain, destination address and metadata. Message queues have corresponding ZK proofs. Once a ZK proof referencing a particular queue is verified on Ethereum, any message from that queue can be safely consumed by its receiving chain and address.

Based on this design, we propose to introduce a unique aggregator component to further improve cross-chain transactions, making them near instant and atomic. The aggregator sits between the Polygon chain and Ethereum and provides two services:

• accept ZK proofs and representations of message queues (e.g. Merkle roots);
• Aggregate ZK proofs into a single ZK proof and submit it to Ethereum for verification.

Once the ZK proof is accepted by the aggregator, the receiving chain can start optimistically accepting inbound messages (knowing that eventual global consistency is guaranteed by the ZK proof), which makes cross-chain interactions seamless. By aggregating ZK proofs, the aggregator greatly reduces the Ethereum Gas consumption for proof verification.

To ensure liveness and censorship resistance, the aggregator shall be run in a decentralized manner by Polygon validators from the public validator pool mentioned above.

Execution layer

The execution layer enables any Polygon chain to generate batches of ordered transactions, also known as blocks. This protocol layer is relatively commoditized; most blockchain networks (Ethereum, Bitcoin, etc.) use it in a similar format.

The execution layer has multiple components such as:

• P2P: enables nodes (validators and full nodes) to discover each other and exchange messages;
• Consensus: enables validators to agree on a single world view (i.e. the blockchain);
• Mempool: Collect transactions submitted by users and synchronize them between validators;
• Database: store transaction history;
• Witness generator: Generate the witness data required by the ZK prover.

Given that this layer is commoditized but relatively complex to implement, existing high-performance implementations (such as Erigon) should be reused as much as possible.

Validation layer

Proof Layer is a high-performance, flexible ZK proof protocol. It generates proofs for all transactions (internal and external (i.e., cross-chain)) for each Polygon chain.

The proof layer has the following components:

• Universal prover: A high-performance ZK prover, developed by ZK researchers at Polygon, as a successor to Plonky2, a recursive SNARK that itself raises the bounds of proof efficiency by two orders of magnitude and demonstrates that Polygon ZK The expertise of the team. The prover provides a clean interface designed to support arbitrary transaction types, the state machine format. Furthermore, using a single prover makes proof aggregation and verification simple and very efficient.
• (Optional) State Machine Constructor: A framework for defining state machines, developed by Polygon's ZK researchers as a successor to PIL, used to build the initial Polygon zkEVM implementation. The constructor abstracts the complexity of the proof mechanism and allows developers to construct state machines through an easy-to-use interface. It is modular; allowing developers to define parameterizable state machines, making it easier to build, test, and audit large and complex state machines.
• State Machine: A simulation of the execution environment and transaction format that the prover is proving. A state machine can be implemented using the above constructors, or it can be completely customized, for example using Rust. Polygon's ZK team provides two state machine implementations - zkEVM and MidenVM - and the community can build other state machine implementations (such as zkWASM).

The proof layer and its high-performance, flexible prover provide several main benefits, Mainly: (i) simple and efficient proof generation, aggregation and verification, (ii) cross-chain communication between different state machines.

Looking to the future

Over the next few days and weeks, we'll be diving into the Polygon 2.0 protocol layers. We'll explore how each of them works at a lower level, and how they come together to form the unique, optimal architecture of the internet's value layer.

As always, we invite the community to review and provide feedback on this proposal and the upcoming deep dive. Let's achieve Polygon 2.0 together!