Scaling Ethereum via the Scroll zkEVM proof system

Bytecode equivalence and infrastructure

Scroll achieved 90 million transactions and 450,000 smart contract deployments during its testing phase. The network launched on Mainnet following two years of development. It functions as a security-focused Ethereum scaling network that uses zero-knowledge technology. The system follows a "2.5 zkEVM" model because it maintains equivalence to the EVM with minor modifications to gas cost structures. Builders migrate applications from Ethereum L1 to Scroll without code modifications because the network preserves bytecode-level compatibility. This approach makes it the best option for developers who require strict architectural alignment with Ethereum. The developers used a fork of Geth for their sorter to inherit a battle-tested system and achieve compatibility with Ethereum. While this design improves stability, the ecosystem currently maintains a lower native TVL than its competitors. The network supports ETH as a native currency for operations such as sending transactions and deploying dApps.

The hierarchical proof mechanism

The Scroll architecture includes three components: the Scroll node, the Roller network, and the verification bridge. The Scroll node contains a sequencer, a coordinator, and a repeater. The orderer receives a batch of transactions from the L2 mempool and executes them to generate a new L2 block, which is then sent to the coordinator for proof generation. The execution trace then goes to the coordinator, which passes it to a randomly chosen Roller to generate a proof. The relayer monitors the state of the L2 blocks, their data availability, and the proof of validity from the rolling contract. The Roller network receives execution traces from the coordinator, sends them to seven different proof circuits, and aggregates them into one final circuit. This process results in a single proof that the coordinator sends to the Rollup contract.

The system uses a Hierarchical Zero-Knowledge Proof System with two distinct layers. The first layer generates proofs for different dApps to ensure fast proving with short proving keys and high scalability through low complexity proofs. This allows people to construct proofs even on their own. This enables privacy-preserving smart contracts with less proving work for the user. Users can also outsource proof generation to miners, who generate proofs effectively without needing big proving keys for multiple dApps. The second layer wraps these proofs to create shorter proofs and a more EVM-compatible system. This wrapping layer acts as a universal on-chain verifier. Noir, a domain-specific language for SNARK proving systems, simplifies the creation of Solidity contracts that communicate with SNARK systems. Developers use the "nargo codegen-verifier tool" to generate verifier contracts efficiently. Noir compiles to an adaptive intermediate language called ACIR. This modular design separates the programming language from the backend, following the modular idea of LLVM. This separation allows developers to select and customize proving systems. Does the complexity of these multi-layer proofs limit adoption for smaller teams?

In the ZK proof process, the engine evaluates transactions off-chain and produces a witness that records intermediate values like the stack, memory, gas, and storage. This engine constructs a circuit that enforces the correctness of the state transition. The process of circuit synthesis transforms high-level zkEVM correctness rules into constraint polynomials. To ensure soundness, the system uses polynomial commitment schemes. The prover commits to the interpolated witness polynomials, and the verifier evaluates the constraint polynomials at random points. This single random evaluation ensures that a given constraint holds at every step of the execution trace. The Fiat-Shamir heuristic eliminates the need for multi-round interaction by letting the prover derive each challenge deterministically. The prover computes the challenge by hashing all prior commitments.

Comparison of scaling performance

Scroll and Polygon zkEVM prioritize different architectural goals. Polygon focuses on scaling privacy within an interconnected network using its AggLayer. Scroll focuses on building verifiably private operations that remain indistinguishable from Ethereum mainnet activity. Scroll implements privacy through partnerships with projects like Nocturne or Aztec. This approach inherits security guarantees from Ethereum.

Metric Scroll zkEVM Polygon zkEVM
Est. Transaction Cost (2026) $0.01 – $0.04 $0.02 – $0.06
Throughput (TPS) ~3,500 ~4,000
Transaction Finality ~15-20 min ~30-60 min
Native Privacy Approach EVM-Equivalent zkRollup Polygon Miden
Developer Tooling Standard EVM Tooling Miden VM, Noir

Scroll provides faster transaction finality than Polygon. Scroll transactions reach finality in 15 to 20 minutes, whereas Polygon transactions take 30 to 60 minutes. You should choose Scroll if you prioritize maximal Ethereum security and bytecode-level compatibility. The costs for transferring ETH on Scroll range from $0.10 to $0.30, while Polygon costs $0.05 to $0.15. In 2026, ZK-based scaling is attractive for exchanges, payment apps, and high frequency DeFi protocols.

Roadmap toward decentralized sequencing

The mainnet launch follows a two-stage process. Phase 1 operates with a centralized sorter and a decentralized prover. The second phase aims to decentralize the sorter. Current research for Phase 2 includes PBS models for MEV extraction and on-chain Challenge mechanisms. The Settlement Layer enables users and dapps to transfer assets and messages between Ethereum and Scroll. It uses the rollup contract and bridge on Ethereum to check validity proofs and provide data availability. The cross-chain bridge contract handles messages sent between L1 and L2, including the bridge transaction of ERC-20 tokens. The Rollup contract receives and stores state root and block data as Ethereum state and calldata, and once the Rollup contract verifies a block proof, the block reaches finality on the Ethereum mainnet.

Newsletter