Ethereum News
Understanding Scroll’s ZK proof system

Understanding the ZK-EVM mechanism
Scroll implements a Type 2 zkEVM that interprets EVM bytecode directly at the bytecode level. This approach allows for EVM-equivalence by providing the same functionality as Ethereum’s L1 without requiring developers to rewrite smart contracts. I find this approach more practical than the language-level compatibility used by ZKsync, where developers compile Solidity into a custom bytecode. While Polygon zkEVM uses an interpreter to translate opcodes into zkASM to speed up proving, Scroll focuses on the correctness of each opcode in the execution trace. This method maintains a closer alignment with the Ethereum specification, even if it results in slower proving times. The project started in early 2021 and aims to build a general-purpose rollup that supports a wide range of transactions. Unlike application-specific rollups that only handle tasks like payments or gaming, Scroll provides a complete environment for any Ethereum application. This Type 2 classification allows the system to stay close to Ethereum’s execution logic while offering the scaling benefits of zero-knowledge proofs.
Prover evolution and the Euclid upgrade
The technology behind the prover evolved from custom opcode circuits to a new architecture in 2025. The Euclid upgrade moved the system toward using OpenVM, a general-purpose RISC-V zkVM developed by Axiom. This upgrade allows the system to prove standard Rust code and simplifies the audit process for the proving pipeline. The current prover uses a hierarchical aggregation system to manage proofs. It first generates chunk proofs for individual blocks. Then, it aggregates these into batch proofs. Finally, the system produces bundle proofs that it converts to SNARKs for on-chain verification. The transition from custom opcode circuits to a RISC-V based architecture like OpenVM allows the system to prove standard Rust code while maintaining the very tight security requirements that are now necessary for a production-ready, secure Ethereum scaling solution. Scroll also researches Ceno, which explores a novel RISC-V architecture using GKR proofs instead of the FRI-based approach.
Security management and audit history
Security for the protocol involves multiple layers of review and testing. The team employs security firms like Trail of Bits, OpenZeppelin, Zellic, and KALOS to review the codebase. The security stack also includes the management of privileged roles. Proxy Admins can change the logic of most contracts, such as the gateway contracts or the L2ScrollMessenger. Implementation Owners have the power to pause relaying or change token mappings. These permissions require careful management through multi-sig wallets to prevent single points of failure. A 2023 review by Trail of Bits found 14 issues, including a high-severity problem where incorrect state transitions could be proven through the manipulation of padding flags. The team also resolved issues where incorrect storage slot calculations in the L2ScrollMessenger contract could impede message verification. Users must also trust the sequencer to not censor transactions, as the current protocol lacks an escape hatch mechanism for fund recovery if the network goes offline. In April 2026, the industry observed the Kelp DAO incident where a bug in a Merkle Mountain Range proof caused a $292M loss. This loss happened because the bug was introduced during a routine upgrade and escaped two independent audits. Will the introduction of automated, continuous security tools prevent such upgrade-induced regressions in the future?
Architecture and user interactions
The architecture splits responsibilities among the Scroll Node, the Roller Network, and the Rollup and Gateway contracts. The Scroll Node builds L2 blocks and handles communication between layers. The Roller Network generates the validity proofs required to verify transactions, while the Rollup and Gateway contracts handle data availability and asset movement. The Rollup contract receives L2 state roots and blocks from the Sequencer and finalizes them once validity is established. The Messenger contracts enable users to pass messages between layers and bridge assets.
| Block State | Description |
|---|---|
| Pre-committed | The sequencer proposes and includes a block in Scroll |
| Committed | The rollup contract on Ethereum receives the transaction data |
| Finalized | An on-chain validity proof confirms the execution is correct |
Users move assets between Ethereum and Scroll using gateway contracts. Standard ERC-20 bridges deploy tokens on L2 automatically, but custom gateways exist for ERC-721 and ERC-1155 tokens. When a user bridges ETH, the L1 messenger contract holds the value. For WETH transfers, the system unwraps the assets to ETH before forwarding them to the messenger contract. Users must provide a gas limit for their L2 transactions, and the relayer deducts a fee from the L1 call based on this limit. You should use the l2geth API to provide your best gas estimations.