Currently, scroll has been launched on Binance’s launchpool event, and it should have been going on for a day, with one day left to go. Those who want to mine need to act quickly, as the total amount this time is quite large. The total amount of Launchpool is 55,000,000 SCR (5.5% of the maximum supply of tokens). In this issue, we will analyze the technical aspects of scroll, the differences between the four king-level ZKEVMs, and the currency price estimates.
1. Scroll Overview
Scroll is an EVM-equivalent zkRollup solution for scaling Ethereum. From a technical perspective, Scroll consists of two main parts. The core part is zkEVM, which is used to prove the correctness of EVM execution at Layer 2.
2. Scroll Architecture
The current architecture consists of three infrastructure components (see Figure 1 below):
1. Scroll Node: Builds L2 blocks from user transactions, submits them to the Ethereum base layer, and passes messages between L1 and L2.
2. Roller Network: Generates zkEVM validity proof to prove the correct execution of the transaction.
3. Rollup and Bridge contracts: provide data availability for Scroll transactions, verify zkEVM validity proofs, and allow users to transfer assets between Ethereum and Scroll.
2.1Scroll Node
The Scroll Node is the primary way applications and users interact with Scroll, and it consists of three modules: Sequencer, Coordinator, and Relayer.
- The Sequencer provides a JSON-RPC interface that accepts L2 transactions. Every few seconds, it fetches a batch of transactions from the L2 memory pool and executes them to generate a new L2 block and a new state root. The Sequencer implementation is based on Go-Ethereum (Geth), one of the most popular Ethereum node implementations. By forking Geth, it is able to achieve the best compatibility and inherit time-tested security.
- When a new block is generated, the Coordinator will be notified and obtain the execution trace of the block from the Sorter. The Coordinator will then dispatch the execution trace to a randomly selected Roller in the Roller pool to generate a proof.
- The Relayer monitors the bridge contract and the Rollup contract deployed on Ethereum and Scroll. It has two main responsibilities: first, it monitors the Rollup contract and tracks the state of L2 blocks, including data availability and validity proofs. Second, it monitors deposit and withdrawal events in the bridge contract deployed on Ethereum and Scroll, and passes messages between the two.
2.2Roller Network
Roller is the prover in the network and is responsible for generating validity proofs for zkRollup. Roller needs to use accelerators such as GPUs, FPGAs, and ASICs to reduce proof time and cost. Figure 2 shows the process of Roller generating validity proofs for each block. The whole process includes the following steps:
1. Roller first converts the execution trace received from the coordinator into a circuit witness.
2. It generates proofs for each zkEVM circuit.
3. Finally, it combines the proofs of multiple zkEVM circuits into one block proof through proof aggregation.
2.3Rollup and Bridge Contracts
Scroll connects to the Ethereum base layer through Rollup and Bridge smart contracts. Together, these contracts ensure data availability for L2 transactions and allow users to transfer assets and messages between L1 and L2.
- The Rollup contract receives the L2 state root and block data from the sorter. It stores the state root in Ethereum's state and stores the L2 block data as Ethereum's calldata. This provides data availability for Scroll blocks and leverages Ethereum's security to ensure that Indexers, including Scroll Relays, are able to reconstruct L2 blocks. Once a block proof verifies the validity of an L2 block in the Rollup contract, the corresponding block is considered finalized on Scroll.
- The Bridge contract is deployed on Ethereum and Scroll, allowing users to pass arbitrary messages between L1 and L2. On top of this messaging protocol, Scroll has also built a trustless bridge protocol that allows users to bidirectionally bridge ERC-20 assets between the two layers. To send a message or funds from Ethereum to Scroll, a user needs to call a `sendMessage` transaction on the Bridge contract. The relayer indexes the transaction on L1 and sends it to the sequencer for inclusion in the L2 block. The process of sending messages from Scroll back to Ethereum happens in a similar way on the L2 Bridge contract.
2.4How does Scroll’s zkRollup work?
Combining these three architectural components, we can summarize Scroll’s zkRollup workflow as shown in Figure 3 below.
The order of steps for L2 block generation in Scroll, submission to the Ethereum base layer and finalization is as follows:
1. The sequencer generates a series of blocks. For the i-th block, the sequencer generates an execution trace T and sends it to the coordinator. At the same time, it also submits the transaction data D as calldata to the Rollup contract on Ethereum to ensure data availability, and submits the resulting state root and the commitment to the transaction data to the Rollup contract as the state.
2. The coordinator randomly selects a Roller to generate a validity proof for each block trajectory. To speed up the proof generation process, proofs for different blocks can be generated in parallel on different Rollers.
3. After generating the block proof P for the i-th block, the Roller sends it back to the coordinator. Every k blocks, the coordinator assigns the aggregation task to another Roller to aggregate these k block proofs into a summary proof A.
4. Finally, the coordinator submits the summary proof A to the Rollup contract, and finalizes the L2 blocks from i+1 to i+k by verifying the summary proof with the state root and transaction data commitment previously submitted to the Rollup contract.
Figure 3 shows the multi-step process of Scroll block finalization on L1. Each L2 block will progress through the following three phases until it is finalized:
- Precommitted means the block has been proposed by the sorter and sent to the Rollers. While precommitted blocks are not yet an official part of the Scroll L2 chain as they have not yet been published to the Ethereum base layer, users who trust the sorter can choose to act on these blocks.
- Committed means that the transaction data of this block has been published to the Rollup contract on Ethereum. This ensures that the block data is available, but has not yet proved that it has been executed in a valid way.
- Finalized means that the execution of transactions in this block has been proven to be correct by verifying the validity proof on the Ethereum chain. Finalized blocks are considered to be officially part of the Scroll L2 chain.
3. Comparison of Scroll and other ZKEVMs
3.1 Basic Background
In 2022, Vitalik Buterin published an article describing four different types of ZKEVM (which were previously introduced when talking about the Kakarot project), namely:
Type 1 zkEVM: Fully equivalent to Ethereum
Type2 class zkEVM: fully compatible with EVM Ethereum Virtual Machine
Type3 zkEVM: Almost compatible with EVM Ethereum Virtual Machine
Type4 zkEVM: Compatible with high-level languages
In the chart, we can actually see that Type4 has good performance, but has low compatibility with evm. Type1 has the highest compatibility, but takes a long time to generate proofs. This seems to be another "impossible triangle", that is, performance and compatibility cannot be achieved at the same time.
3.2 Four categories proposed by Immutable
ZKsync: Currently a type 4 zkEVM, fully compatible with the Solidity programming language. With zkSync, users can choose between two data availability types: zkSync Rollup and zkSync Porter. The former publishes data directly on Ethereum, making it as secure as Ethereum L1, while the latter stores data off-chain, resulting in faster transactions and lower costs, but with a lower level of security.
zkSync is EVM-compatible in that it can convert smart contract code written in Solidity to Yul, and Yul to LLVM-IR (Intermediate Representation, which represents an intermediate representation of machine code), which is then recompiled into a custom circuit-compatible bytecode set specifically designed for the EVM for zkSync. While this requires an intermediate step, it also allows for the addition of other non-EVM features such as Account Abstraction. In addition, zkSync's company Matter Labs plans to gradually make it more compatible with the Ethereum toolkit and is preparing to launch its first three-layer prototype, zkSync Opportunity, on a testnet as part of its ambitions in the field of scalability and interoperability.
StarkNET: StarkNet is a type 4 / Solidity compatible zk-rollup that employs a different type of zero-knowledge proofs called STARKs (Scalable Transparent ARgument of Knowledge) to ensure the integrity of off-chain transactions. STARKs are considered more efficient and scalable than SNARKs, but may require a more complex technical setup.
While StarkNet also supports smart contracts, its capabilities are relatively limited due to the use of STARKs and the fact that StarkNet contracts and the StarkNet OS are written in the Cairo language. To make development easier, StarkWare recently upgraded to Cairo 1.0, which emulates Rust. Like zkSync Era, StarkNet can be classified as "Solidity compatible" because it does not execute programs within the EVM, but instead creates an entirely new, specially designed VM with a custom bytecode. StarkWare uses the Warp transpiler to convert Solidity code into Cairo VM bytecode.
However, unlike zkSync Era and other zkEVM implementations, the StarkNet team does not aim to be compatible with the EVM or other Ethereum components, but rather aims to make StarkNet's VM as efficient as possible by rolling its custom client API, JavaScript library, and wallet system, which will force Ethereum-compatible tools to manually add StarkNet support. Although Cairo 1.0 also introduces Sierra - Secure Intermediate Representation - as a new intermediate representation layer between Cairo 1.0 and Cairo bytecode, the Warp transpiler does not support certain Solidity features and is still a long way from matching zkSync Era's EVM compatibility.
Polygon ZKEVM: It uses a custom language zkASM to interpret zkEVM code and verify the execution of smart contracts in a non-EVM runtime environment. In addition to Polygon zkEVM, Polygon has also developed Polygon Avail, a blockchain that optimizes data availability only. The network will be permissionless, allowing anyone to join as a validator, and unlike existing DACs (Data Availability Committees), it will have hundreds of nodes collaborating to provide network security. Avail will work in pair with Polygon Hermez (Rollup), uploading state data from Hermez instead of publishing it on Ethereum, providing a solution between Validium and Rollup.
Scroll:Scroll is an EVM equivalent zk-rollup developed by the Scroll team in collaboration with the Ethereum Foundation's PSE (Privacy and Scaling Explorations) group, designed to be fully compatible with the Ethereum Virtual Machine (EVM) at the bytecode level. This means that developers can create smart contracts in any EVM-compatible language and deploy them to Scroll. Although Scroll does not currently support EVM opcode, it is planned to do so by building a 1:1 opcode mapping and directly accepting EVM opcode without the need for a compiler.
4. Coin Price Estimation
The total number of tokens is 1,000,000,000, with an initial circulation of 190,000,000. The token distribution is 35% to the ecosystem (25% to ecological growth, 10% to DAO treasury), 10% to the foundation, 23% to contributors, 17% to investors, and 15% to airdrops.
In terms of TVL, Scroll is leading, and ZKsync is in second place. Currently, zksync’s FDV is 2.5 billion, and it has just launched at nearly 5 billion. Straknet’s current FDV is 3.8 billion, and it has just launched at 20 billion. According to the previous launchpool revenue calculation (1%-2%), the expected launch price is between 2.2 and 4.4 US dollars, and the corresponding market value is between 2 billion and 4 billion. In fact, this valuation is still relatively low, because this kind of project will definitely have a premium when it goes online, so the current estimate should be more than 5 US dollars.
