Scroll 백서

Scroll

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 1쪽 중 1쪽

Scroll White Paper V 1.0 24 June 2024 Content Page Abstract 3 Introduction 3 Background 3 Rollups 3 Scroll zkEVM 4 Technical Overview 4 Scroll zkRollup 4 Execution Environment 5 Transaction Life Cycle 5 Sequencing Transactions 6 The zkEVM 8 EVM Execution 8 Proving an EVM execution 10 Conclusion 12 Abstract Scroll is a Layer 2 scaling solution for Ethereum that leverages zero-knowledge rollups (zk-rollups) to enhance scalability, reduce transaction costs, and maintain security and decentralization. This whitepaper outlines the architectural design and technical specifications, emphasizing its role in the Ethereum ecosystem and its potential to transform decentralized applications (dApps) by providing a more efficient and scalable infrastructure. Introduction Background Ethereum, since its inception in 2015, has achieved a significant increase in user activity, leading to network congestion, high gas fees, and slower transaction times. These scalability issues are the result of making tradeoffs prioritizing security and decentralization. Various Layer 2 solutions have been proposed and implemented to address these issues, with ZK rollups emerging as a preeminent solution due to their ability to enhance scalability without compromising security and without introducing additional trust assumptions for the user. Rollups Rollups are the most predominant layer 2 scaling solution in the Ethereum ecosystem and are viewed as a central part of the Ethereum roadmap. A rollup processes batches of transactions off-chain (i.e. not on layer 1), and then posts the resulting data on-chain (i.e. on layer 1). The execution of each transaction is performed off-chain, and does not need to be re-executed by layer 1 nodes. This allows for high transaction throughput, without impacting the decentralization of layer 1. Rollups must safely handle state validation, verifiably publish chain data, give users sufficient notice before upgrades, and enable mechanisms for processing transactions if chain operators go offline or censor users. Scroll must account for all of these in its protocol design, but our most novel contribution to the space is validating the state transition function for a set of incoming transactions. In order for a rollup to be secure, it must prove that its off-chain computation (the processing of transactions) was performed correctly. ZK rollups use zero-knowledge proofs as the mechanism for ensuring state-transition correctness, and the Scroll zkEVM is responsible for this in Scroll. Scroll zkEVM Scroll zkEVM aims to provide a scalable, secure, and cost-effective solution for Ethereum by integrating zero-knowledge proof technology with the Ethereum Virtual Machine (EVM). By doing so, Scroll zkEVM ensures compatibility with existing Ethereum smart contracts while significantly improving transaction throughput and reducing costs. While we leverage the Scroll zkEVM for creating a scalable blockchain network, its uses extend to verifiable vulnerability reports for dApps, highly secure bridges, and more. Technical Overview Scroll zkRollup Scroll’s network consists of three layers: ● Settlement Layer : provides data availability and ordering for the canonical Scroll chain, verifies validity proofs, and allows users and dapps to send messages and assets between Ethereum and Scroll. Scroll uses Ethereum as the Settlement Layer and deploys the bridge and rollup contract onto Ethereum. ● Sequencing Layer : contains an Execution Node that executes the transactions submitted to the Scroll sequencer and the transactions submitted to the L1 bridge contract and produces L2 blocks, and a Rollup Node that batches transactions, posts transaction data, and block information to Ethereum for data availability, and submits validity proofs to Ethereum for finality. ● Proving Layer : consists of a pool of provers that are responsible for generating the zkEVM validity proofs that verify the correctness of L2 transactions, and a coordinator that dispatches the proving tasks to provers and relays the proofs to the Rollup Node to finalize on Ethereum. Execution Environment Scroll takes the EVM as a starting point for how the network behaves, with a codebase based on Ethereum mainnet’s pre-eminent geth node. Minimal modifications are made to support additional rollup mechanisms, including modifying the state tree to better support ZK proving, and the introduction of L1 Message Transactions for coordinating with incoming information from L1. Transaction Life Cycle The transaction life cycle in the Scroll contains the following three phases: 1. Confirmed : Users submits a transaction to either the L1 bridge contract or L2 sequencer. The transaction becomes Confirmed after it gets executed and included in an L2 block. 2. Committed : The transactions are included in a batch and a commit transaction that contains the data of this batch is submitted to L1. After the commit transaction is finalized in the L1 blocks, the transactions in this batch become Committed . 3. Finalized : The validity proof of this batch is generated and verified on the L1. After the finalize transaction is finalized on L1, the status of the transaction is Finalized and becomes a canonical part of the Scroll L2 chain. [The next section on ‘Sequencing Transactions’ can be found on the next page.] Sequencing Transactions The L2 sequencer contains three modules: ● Sync service subscribes to the event issued from the L1 bridge contract. Once it detects any newly appended messages to the L1 inbox, the Sync Service will generate a new L1MessageTx transaction accordingly and add it to the local L1 transaction queue. ● Mempool collects the transactions that are directly submitted to the L2 sequencer. ● Executor pulls the transactions from both the L1 transaction queue and L2 mempool, executes them to construct a new L2 block. The rollup node contains three modules: ● Relayer submits the commit transactions and finalizes transactions to the rollup contract for data availability and finality. ● Chunk Proposer and Batch Proposer propose new chunks and new batches following the constraints described in the Transaction Batching . The rollup process can be broken down into three phases: transaction execution, batching and data commitment, and proof generation and finalization. Phase 1. Transaction Execution 1. Users submit transactions to L1 bridge contract or L2 sequencers. 2. The Sync Service in the L2 sequencer fetches the latest appended L1 transactions from the bridge contract. 3. The L2 sequencer processes the transactions from both the L1 message queue and the L2 mempool to construct L2 blocks. Phase 2. Batching and Data Commitment 1. The rollup node monitors the latest L2 blocks and fetches the transaction data. 2. If the criterion (described in the Transaction Batching ) are met, the rollup node proposes a new chunk or a batch and writes it to the database. Otherwise, the rollup node keeps waiting for more blocks or chunks. 3. Once a new batch is created, the rollup relayer collects the transaction data in this batch and submits a Commit Transaction to the rollup contract for data availability. Phase 3. Proof Generation and Finalization 1. Once the coordinator polls a new chunk or batch from the database: ○ Upon a new chunk, the coordinator will query the execution traces of all blocks in this chunk from the L2 sequencer and then send a chunk proving task to a randomly selected zkEVM prover. ○ Upon a new batch, the coordinator will collect the chunk proofs of all chunks in this batch from the database and dispatch a batch proving task to a randomly selected aggregator prover. 2. Upon the coordinator receives a chunk or batch proofs from a prover, it will write the proof to the database. 3. Once the rollup relayer polls a new batch proof from the database, it will submit a Finalize Transaction to the rollup contract to verify the proof. Commit Transaction The Commit Transaction submits the block information and transaction data to L1 for data availability. The transaction includes the parent batch header, chunk data, and a bitmap of skipped L1 messages. The parent batch header designates the previous batch that this batch links to. The parent batch must be committed before; otherwise, the transaction will be reverted. Finalize Transaction The Finalize Transaction made to the L1 finalizes the previously-committed batch with a validity proof. The transaction also submits the state root and the withdraw root after the batch. At this stage, the state root of the latest finalized batch can be used trustlessly and the withdrawal transactions in that batch can be executed on L1 using the Merkle proof to the withdraw root. The zkEVM The zkEVM is the core of Scroll’s technology, enabling the generation of zk proofs for Ethereum-like transactions. This allows Scroll to maintain compatibility with existing Ethereum tools and applications while offering enhanced scalability. Collaboration with PSE and Halo2 Scroll’s zkEVM is built in collaboration with the Privacy and Scaling Explorations (PSE) team and leverages Halo2, an advanced proving system. This collaboration ensures that Scroll benefits from cutting-edge research and technology in zk proof systems. Hardware-Focused Design Scroll’s zkEVM is designed with a focus on hardware optimization, utilizing GPU provers to accelerate proof generation. This hardware-focused approach ensures that Scroll can handle high transaction volumes with lower latency. EVM Execution In order to understand how to build a zkEVM, which proves the execution of the EVM, we need to first look at the EVM itself. The EVM can be modeled as a state transition function. It specifies a transition function f that, given an initial world state S and a transaction T , outputs a new world state S’ : f(S,T) = S' . The “world state” is modeled as a modified Merkle-Patricia Trie (MPT). This trie contains all of the network’s persistent data. This includes the information of all externally-owned accounts (EOAs) and smart contract accounts. Smart contract accounts have sub-tries that hold the smart contract’s bytecode and persistent storage. The EVM processes a new transaction by executing its resulting computations and making changes to the world state accordingly. EVM computation works over transient data stores (stack and memory) as well as persistent data stores (contract bytecode and storage). A diagram to explain this can be found on the next page at Fig. 1. ( Fig. 1. ) The computation triggered by an individual transaction is broken down into small machine instructions called “opcodes,” which the EVM can directly understand and execute. The behavior of each opcode is specified in the Ethereum Yellow Paper. The execution of a transaction can therefore be summarized by an “execution trace,” which is simply an ordered list of opcode executions. Ethereum execution clients, such as Geth, can explicitly output a step-by-step execution trace for the computation it has performed. A diagram to explain this can be found on the next page at Fig. 2. ( Fig. 2. ) As the opcodes are executed, the state trie is altered. This results in a new state trie, with a new state root. Proving an EVM execution The goal of a zkEVM is to generate a proof attesting to the validity of a transaction’s execution. In other words, given an initial world state S , a transaction T , and a resulting world state S' , the zkEVM must generate a proof that f(S,T) = S' , where f is the state transition function specified in the Ethereum Yellow Paper. In order to prove the validity of the transition function execution, we break down the execution into its step-by-step execution trace. The execution of f(S,T) is expanded into a list of its sequential opcode executions. The execution trace serves as a “witness” attesting to the correctness of the state transition f(S,T) = S' - the trace in a sense a step-by-step explanation of how the state transitions from S to S' . The problem is then reduced to proving the following: ● The execution trace is correct . ○ Each individual opcode is correctly executed according to the Ethereum Yellow Paper spec. ■ For example, the ADD opcode must result in popping two values off the stack, and pushing their sum to the stack. ■ A proof must show that each opcode was executed with the proper behavior, including any alterations to transient data stores (stack and memory) or persistent data stores (contract bytecode and storage). ○ The ordered list of opcodes being executed is in fact the correct list of opcodes triggered by the transaction. ■ This includes correctly loading the initial transaction calldata, and the bytecode for any invoked contracts. ● The execution trace starts with initial state S and results in state S' . This process is explained here in Fig. 3. ( Fig. 3. ) Conclusion Scroll represents a significant advancement in Ethereum scaling solutions, leveraging zkEVM technology to offer a scalable, secure, and efficient rollup solution. By integrating advanced zk proof systems and optimizing for hardware performance, Scroll is positioned to address the scalability challenges of Ethereum while maintaining compatibility with the broader Ethereum ecosystem. This whitepaper outlines the technical components of Scroll, highlighting its enhancements over the base Ethereum protocol and detailing the mechanisms that ensure its security and efficiency. For further details and technical specifications, please refer to the Scroll zkEVM documentation and resources available on the official website.
프로젝트로 돌아가기