Delphi Digital: The Complete Guide to Rollup Part 2 – Ethereum Rollup Stack

This article is The Complete Guide to Rollups published by the research institute Delphi Digital. The article is divided into three parts, compiled by The Way of DeFi:

  • Part 1 – Modular Economics‌
  • Part 2 – Ethereum Rollup Stack
  • Part 3 – The Celestia Rollup Stack

This article is the second part of the report, compiled by Kyle and Wendy:

Part 2 – Ethereum Rollup Stack

Recently, Mustafa (Celestia Labs) gave the most concise definition of Rollups in an article, I will quote it here: Rollup is a blockchain that publishes its blocks to another blockchain, and inherits the blockchain Consensus and DA.

Various roles exist in Rollup, such as sequencer, proposer, prover, and challenger, depending on the actual deployment. I refer to them collectively as “operators”. Operators regularly release data to the base layer in combination with user transactions. They also commit to the latest Rollup state (eg, Merkle root).

Anyone can use the compressed transaction data (as long as it is available) to recreate the state and check if a state transition is valid. Rollup light clients do not download and execute full transaction data, so they rely on fraud/validity proofs to guarantee the validity of state transitions.

Ethereum – Smart Contract Rollup

This can be seen in current Ethereum (e.g. Arbitrum, Optimism, StarkNet, zkSync, etc.). Here’s how they work:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Smart Contract Rollups (SCR) effectively operate in numerous L1 smart contracts. Rollup execution is processed off-chain, and operators regularly publish data to L1. Smart contracts verify proofs/arbitrate disputes as needed. They also keep track of all the Rollup state roots and transaction data so they can recompute the state:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

A proof of fraud (ORU) or validity (ZKR) then confirms the validity of the state transition. The operator posts the deposit in the L1 smart contract to publish the block. If the block or proof is invalid, their deposit can be slashed and the transaction will not be finalized. This may take more than a week for ORU, but the proof of effectiveness can seal the final result in no time.

Submitting and arbitrating a fraud proof is actually quite fast. The ORU takes so long mainly because the L1 smart contract needs to receive proofs, which may be censored. In the case of L1 proof of censorship, we need time to reconcile through social consensus.

These smart contracts also act as trust-minimized two-way bridges between Rollup and L1. This is one of their key advantages. It is trust-minimized because Rollup implicitly does full verification of Ethereum, and smart contracts on L1 take on the role of Rollup light clients (receiving block headers protected by fraud/validity proofs).

Now is the time for FUD.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

These are always smart contracts. Just recently, we’ve just witnessed horrific cross-chain bridge attacks‌ (mainly all bugs, not related to key cracked or economic attacks). Rollups are also not immune. This contract is a very specific trust-minimized two-way bridge, but it’s still a bridge. Even small mistakes in your code can cost you a lot.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

That’s why many Rollup teams are holding onto their upgrade keys tightly. Often there is a multi-signature committee, there is an escalation notice period, and in other cases the code can even be changed arbitrarily by the team without notice.

Between security and trustlessness, the timing of the upgrade needs to be balanced. If you find a bug, you probably don’t want to hype it up in the admin forums and wait a month, but want to fix it right away.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

One idea is to have a delayed upgrade feature, but add a stop option that stops the Rollup immediately. While suspending a rollup is a bummer, it does reduce trust in upgrade key holders.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Bartek (Maker Foundation) recently gave a great Rollup FUD talk on this topic and L2 Beat’s risk framework, link here‌.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

I understand that Rollup will take time to mature. What I would say is that we need to be realistic about where we are at the moment. Like centralized orderers and fraud proofs (if any), these teams intend to gradually decentralize.

There are two options for handing over an upgrade key:

1. Immutable Rollup – No one can upgrade smart contracts (unless L1 forks). This is a huge sacrifice. Basically you’ve accepted that this Rollup will eventually be scrapped and you’ll be deploying another instance from scratch. Rollup that wants to be equivalent to EVM (Ethereum Virtual Machine) absolutely cannot. When L1 changes, they must upgrade their virtual machines to be consistent. Fuel v1 is currently the only ever-changing Rollup on Ethereum.

2. Decentralized governance – this is what I actually expect. While it adds trust assumptions on top of L1 transactions, Rollup governance now controls the upgrade keys. Smart Contract Rollups (SCR) can be built on a delayed basis (set to be longer than the withdrawal period for Rollups) before the upgrade takes effect. Don’t like this upgrade? Then you can safely exit. This is trust minimization because you are now only doing Rollup governance based on the synchronization assumption (instead of the honest majority assumption). You just assume you see the planned upgrade and quit before then.

Here, some of the major Rollup teams have great conversations about their thoughts on decentralization.

Back to the last point – the exit of Rollup. A safe exit L1 execution layer is a good fallback. Ethereum has this option, but Celestia does not. They are useful in individual cases, but in future L1 gas of $1000/transaction would quickly force thousands of users back to L1 with a small amount of funds, which doesn’t seem ideal . One area that should be explored more is the possibility of designing an exit to another rollup.

Overview of the main points

Trust-minimized two-way bridges are extremely valuable – there is a huge ecosystem where all Rollups are mining for shared liquidity and interoperability. Most of the time, it’s fine to condense security assumptions into an ultra-secure base layer.

But the bugs and upgradability of smart contracts are still a bit scary at the moment. Immutable Rollups alleviate many concerns, but it’s a price not worth paying.

Ultimately, robust contracts with well-designed governance (with escalation delays) will be the best solution to approach the security of L1 itself.

Ethereum – Smart Contract Settlement Rollup and Smart Contract Recursive Rollup

StarkNet has some pretty cool fractal scaling plans, here’s a concrete example:

1. Today – StarkEx, dYdX, Sorare and Immutable X are already in operation on a large scale. But they are not universal or composable. They are silos created through a contractual agreement with StarkWare.

2. Soon – StarkNet will appear. Like the smart contract Rollups (SCR) we are used to, a generic permissionless Rollup.

3. Later – Fractal expansion. StarkEx (and other L3s) can be deployed on top of StarkNet:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

At this stage, the relationship between L2 and L1 is as follows:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

With L3 it looks like this:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Recursion turns out to be a pretty exciting scaling path. A validator contract on L2 can accept many L3 proofs of validity, create a proof of validity, prove that it verifies those proofs, and publish this proof to Ethereum. This efficiency is important in a gas-constrained environment like Ethereum. L3 may also experiment with off-chain DA solutions to further reduce costs (albeit with stronger security assumptions).

Rollup for specific applications

These L3s are naturally suitable for application-specific ZKRs. A large part of L3’s appeal is being able to control its own environment away from “noisy neighbors” while preserving its network effects through the L2 settlement layer. As bridges and interoperability continue to improve, I would like to see more deployments of application-specific ZKRs. They will retain most of the advantages of a shared execution environment, but get rid of the disadvantages.

Also – show me the incentives and I’ll show you the results. Application-specific Rollups capture more value than deploying smart contracts directly, because your tokens now capture execution fees and other MEVs. But if leaving a shared execution environment isolates you, it’s not worth the tradeoff. This is why (as I said before) better bridges, liquidity sharing, etc. are critical to the development of this trend.

Overview of the main points

Recursive Rollups present a very attractive value proposition, especially for application-specific use cases. You can achieve greater scale in an agile environment while preserving network effects. L2 could serve as a more scalable settlement layer than what Ethereum can currently do. As long as their data is sent back to L1, they have L2-like security guarantees – they are able to recreate state and exit.

Ethereum – Enshrined Rollups?

The crazy thing is that Enshrined Rollups (ER) is a bit futuristic. They are full of controversy, which makes them even more interesting.

You’ve probably heard ERs being talked about over and over on Twitter, but don’t actually know what they are, since no one has written about them extensively (except Justin Drake‌, who helped me a lot in this section) ‘s article.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

ER is built directly into the L1 specification rather than being deployed as a smart contract. This eliminates malicious governance/multi-signature upgrades or bug risks (outside of Ethereum itself). They follow the social consensus of the base layer within the scope of the hard fork.

When Ethereum merges (The Merge), the execution layer (Eth1) will merge with the consensus layer (Eth2). The execution layer (settlement is done by the consensus layer) can be upgraded to an enshrined rollup (ER).

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Enshrined Rollups–Optimistic Rollup vs. zkEVM

In contrast, Optimistic Rollup (ORU) transitions to ER may be the fastest. Since weak statelessness already exists in the Ethereum roadmap, you can easily add fraud proofs. The simplest fraud proof is to distribute the block itself in isolation for re-execution (which will now include witnesses as well as pre/post state roots, transactions, etc.). However, fraud proof and transaction finality conflict, so the effect is not ideal.

An ambitious “plan” is to move directly to enshrined ZKRollup (ZKR). The Ethereum Foundation already has a team led by Barry Whitehat that is currently building a zkEVM. The caveat is that this is a daunting task that can take years.

Whether it’s ORU or ZKR, the point is that full nodes no longer need to execute transactions (unless fraud proof). This also applies to consensus nodes – neither the proposer nor anyone in the committee will execute the transaction.

Step 1 – Upgrade Settlement Layer to Enshrined zkEVM Rollup

“Settlement layer upgrade to Enshrined zkEVM Rollup. The entire Ethereum ecosystem – potentially thousands of Rollups/volitions and millions of TPS – will be validated by a neat ZKP. Hallelujah.”

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

This is an uncontroversial step (once the technology is safe, easy to understand, etc.). The single-instance EVM as we know it today is upgraded to the state root equivalent of the zkEVM. This means that every L1 block comes with a SNARK that proves that the state root is valid.

Although there are some public implementation details, it’s still years away. Regarding proof distribution, you now have two options:

  • Sidecar – A SNARK (or SNARK, an implementation detail) is just sent as a sidecar and one can implicitly verify it.
  • On-chain – SNARKs are actually on-chain, and smart contracts can easily access the proof itself to verify it.

Ultimately, there are two layers of consensus – social and code. The sidecar approach leans toward social dependencies, while the on-chain approach leans toward code.

performance bottleneck

As mentioned earlier, ER eliminates the need for full nodes to re-execute transactions. This makes syncing to the chain easier, and it also removes the computational bottleneck for validators. Currently validators have several consensus bottlenecks:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Weak statelessness has broken storage and disk I/O – removing our major bottlenecks today. But at this stage, full nodes still need to execute every transaction. Obtaining a SNARK for the validity of each block will also cause the computation to fail. Both stateless and zkEVM represent an opportunity to increase the gas limit while removing more bottlenecks. Bandwidth is the only remaining major resource requirement (which is also proportional to Nielsen’s law).

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Benefits of zkEVM Enshrined Rollup

  • Simpler consensus – stateless (no fraud proofs) still requires full node execution, but zkEVM removes this bottleneck. Execution clients can swap thousands of lines of consensus-critical EVM execution code for simpler SNARK validation code.
  • Stateless Witness – Statelessness allows consensus nodes to stop maintaining state. They now receive witnesses (Verkle proofs) attesting to the correct state access and transactions in each block. zkEVM also removes this need – state differences are sufficient. This increases the validator’s consensus bandwidth efficiency, allowing for higher gas limits.
  • Safer Light Clients – Light clients use SNARKs to filter invalid state roots much faster than using fraud proofs. This allows for a more secure and/or faster Ethereum-to-competitive L1 bridge.

Step 2 – Deploy a massively parallel zkEVM Enshrined Rollup

Oh, you thought the execution sharding design was canceled, did you? This is the next thing to talk about – ER.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

After upgrading a single instance EVM, it is not difficult to deploy multiple (eg 64) parallel zkEVM ERs. This is a form of homogeneous L1 execution sharding. It’s also a question of whether such sharding will be needed anytime soon. As a zkEVM ER, single-instance throughput can increase by orders of magnitude over current capacity.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

The distinction between typical execution sharding and ER seems blurry, and there’s been a lot of messy debate on Twitter about it. The key point is again that full nodes do not need to execute ER blocks. Therefore, an executing shard with a zk-proof state root can be an ER. You get the same scalability and functionality as regular SCR (proposers only need to accept proofs and check DA), but you get the advantages of Rollup in consensus (more on that later).

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

The old execution shard assigned a subset of the Ethereum validator set to each shard. Each monolithic shard will handle its own execution, consensus and DA, and then checkpoint back to the beacon chain.

The zkEVM ER only handles execution (making it more efficient), similar to the Rollup we see today. They rely on the beacon chain for consensus, settlement (issue proofs), and DA (they consume data blobs).

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Another implementation detail concerns the committee. There can be a committee of proposers in each rollup to validate the SNARK, which is then sent to the main settlement Rollup. Alternatively, you can skip committees and have Rollup block producers send SNARKs directly to the main chain where all proposers operate.

Either way, the proposer just accepts the highest bid, checks the DA, and verifies the SNARK that comes with each Rollup block as an extra field. You can think of it as one big block. It looks like this:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Advantages of zkEVM Enshrined Rollups

It might seem obvious to upgrade the current settlement layer, but what is the benefit of having all these other zkEVMs compared to just being a zkEVM SCR?

  • Social Consistency – ER inherits the L1 social consensus. SCR currently has centralized operators holding upgrade keys, and ultimately this risk will lie in Rollup governance.
  • Economic Consistency – All ER fees and MEVs are credited to ETH. Nuclear Zombies Apocalypse World War 3 Economic Security.
  • Subsidized Proof Verification – ER can subsidize the cost of proof verification, while SCR has to pay EVM gas for settlement. In any case, validating SNARKs will be very cheap at this point. This alleviates the problem of rollup jobs today. Aggregators like Arbitrum, for example, delay settlement to avoid L1 gas spikes that sometimes occur.
  • Optimal settlement latency – Consensus can enforce SNARK proofs for each ER block, providing per-block settlement latency.
  • Optimal Activity – Centralized Rollup Sequencers may experience a drop in activity (we’ve seen this happen). SCRs also have the option of letting the sequencers reach their own consensus to provide pre-confirmation (StarkNet will do this). This suffers from suboptimal liveness, as external consensus can fail and the L1 escape hatch will only activate after a timeout.
  • State Root EVM Equivalence – Current tools and light clients will work out of the box. Today’s SCRs are primarily aimed at Solidity-compatible VMs (eg zkSync) or bytecode equivalent EVMs (eg Scroll), not full EVM state root equivalence.
  • Network Effects – Take the EVM’s network effects even further from where it already leads. There is value in allowing developers to coalesce around a standard. (Although, conversely, experimenting with new virtual machines may also yield exciting possibilities).
  • Maximize gas efficiency – ER uses native opcodes because they are built into the protocol. Instead, SCR may have to address VM inefficiencies.

Disadvantages of zkEVM Enshrined Rollups

But they are not perfect:

  • No Public Goods Financing – Private Rollups like Optimism can repurpose their revenue to fund public goods at their discretion. ER will be limited to funding L1 security and burning ETH.
  • Suboptimal compression – SCR currently settles on-chain much less frequently than per block, enabling better data compression. They may also have custom or frequently updated dictionaries to improve data compression.
  • VM is not flexible – Ethereum ER is likely to be an EVM. SCR can take other popular VMs (eg, WASM, RISC-V, MIPS) or create a new VM (eg, Cairo, FuelVM). A custom zkVM might be able to achieve better data compression than zkEVM.
  • Harder pre-confirmation – SCR may choose to have a centralized sequencer that provides instant (~100ms) pre-confirmation for a better user experience. This is more difficult to achieve with ER’s decentralized sorting.
  • Last mover – Due to the conservative nature of L1, the ER is very slow to make any changes. Various upgrades will need to be implemented through the governance process (EIP and forks). To avoid circuit errors, redundant multi-circuit setups (eg, 2-of-3 signatures) or heavy formal verification may be required.
  • Potentially increased builder cost – the builder must now create a proof unless the sequencer and the prover are split into different roles (this is possible, implementation details). Ethereum could also decide to issue ETH to offset ER proof costs. This raises the question of “how specialized will block building end up being?”. I’m currently expecting meaningful centralization anyway (due to economic incentives, as I’ve written before), but we’re not sure. Once implemented, the proof will also greatly reduce cost and speed.
  • Justin will have to redo his predictions because too much ETH will be destroyed.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Speculative Advantages of zkEVM Enshrined Rollups

Builders running (or possibly building all Rollup blocks, settlements and data) across multiple ERs can provide synchronized interoperability between ZKRs.

For example, a builder can provide collateral and promise to include your sync transaction. If they accept your bid but fail to execute the trade, they will lose their deposit. crLists can also help provide pre-confirmation, as proposers (who can also choose to be tied to collateral) will be able to force transactions to be included.

Economic incentives lead builders to operate across Rollups – we are already seeing this centralized power in cross-chain MEVs today. These soft confirmations of synchronous interoperability are what users want, and they pay for. If you can provide this service, you can make more money. If you can make more money than everyone else, you’ll be the best builder.

Note that even before this, ZKR makes synchronous calls to L1, and similar dynamics are in play. The new danksharding design preserves this possibility as everything is confirmed in one block. For example, you can bridge funds to L1 and then perform an exchange with those funds in the same block. However, to provide this service, you need to control the production of L1 and L2 blocks to ensure that both legs execute (ie, the funds are only bridged when this swap executes immediately after it). This is a centralized force for block builders across Rollup and L1.

Arguments Against Enshrined Rollups – Credible Neutral

Upgrading a single-instance EVM to zkEVM seems like a no-brainer (if we’re comfortable with the technology). The next step for 64 Enshrined Rollups is the more controversial part.

“It turns out that most of the content in the blockchain is opinion, not technical content.” The case against ER is no exception here. Here’s a fun Ethereum dev, Celestia dev, and Ethereum spam post that makes a good case on both sides. There are many disagreements here. Some people worry that the ER will do this to the SCR:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

The argument is that ER would essentially compete with the SCR that Ethereum is trying to foster, compromising its credible neutrality. SCRs can feel like “second-class citizens.” It could “limit the trusted neutrality of the Ethereum settlement layer, weakening its socioeconomic safeguards for non-ERs.” This is similar to the debate on the minimalism of the Cosmos Hub. This interesting balance of base layer functionality/minimalism is also discussed by Vitalik before.

Rationale for Enshrined Rollups – Trusted Neutral

Instead, some argue that ER can protect Ethereum’s trusted neutrality by preventing any commercial rollup teams from becoming too dominant. Let’s say “Rollup Labs A” becomes so successful that their Rollup crowds out everyone else. Such reliance on a private team could seriously affect Ethereum’s trusted neutrality and network effects. A neutral balance from the ER can alleviate this.

Taking it a step further, a successful Rollup ecosystem can even break away from their Ethereum consortium.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Here’s an argument Ali Atiia has made in the past:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

The current Ethereum scaling plan is primarily a DA layer as a SCR with a constrained settlement layer. Ethereum relies on Rollup for scalable computation. However, SCRs can cut out the “old middlemen” and introduce their own rollup of local assets.

The hypothetical example cited is that Optimism, Circle (USDC), MakerDAO (DAI) all have the same investors. Investors facilitate cross-pollination of the protocol, and locally deployed assets are cheaper and the user experience is better. Therefore, it makes economic sense for Circle and MakerDAO to deploy USDC and DAI, respectively, on Optimism. Once Rollup has built enough native assets, DeFi, and security, they may decide that Ethereum no longer provides them with enough value.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

To build stickiness, Ethereum needs a better settlement layer. DA alone may not be sticky enough. To build the best settlement layer, you need scalability and shared liquidity. ER makes communication between SCRs much more efficient. The “hyperscale” L3 we hear about today may become more viable a layer on top of Ethereum’s ER. ER becomes the go-to place for sovereign and institutional settlements using the most valuable dApps = massive liquidity.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Personal opinion on Enshrined Rollups (ER)

ER does not threaten the trusted neutrality of Ethereum. Yes, the activity will take place on the ER that could theoretically have gone to the SCR. But this is the exact same argument against Ethereum SCR and continues to be spread by many single, competing L1 proponents. SCRs are not parasitic on Ethereum – they are synergistic. ERs do not parasitize SCRs – they are synergistic. Ethereum is best to use SCR, and SCR is best to use ER.

ER made this pie a lot more than they could eat on their own.

SCRs will always be home to innovation and higher expansion, so they will continue to host the vast majority of Rollup activity. ER is designed to ensure that Ethereum can live up to its promise of maintaining an optimal settlement layer:

  • Trust-minimized bridging and access to the largest shared liquidity pool
  • Higher spreads allow for significantly lower bridging costs for SCRs located on top, opening up incredibly exciting new possibilities

I don’t share Ali’s concerns that Ethereum will break away, although others have similar sentiments:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

If Rollups are economically rational players, they have a simple equation to measure:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

ER skews this scaling more favorably in both directions – they make Ethereum a better settlement layer, and they provide lower costs for SCR on top.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Splitting the Rollup into isolated L1s (with unsafe bridges) shrinks this pie considerably, and you only get marginally higher margins in return (saving cheap settlement fees). Additionally, you now need to subsidize your security, most likely by issuing inflationary block rewards. It doesn’t make economic sense.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

A potentially economically sound argument for why Rollup would leave Ethereum is whether they could build a better settlement layer. Then in theory you might end up with a bigger pie. The only way I think anyone has a chance is to use the following:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

However, you make huge sacrifices in terms of network effects, decentralization, and trusted neutrality in the second half. It makes more sense to build a settlement layer on top of Ethereum, as StarkNet did with their L2. You get the best of both worlds – a high-value financial settlement layer that retains the great advantages of Ethereum at a very low price.

Protocol complexity

Vitalik touched on a very important topic in his recent EthCC talk. Ethereum is entering its fastest period of innovation. Lots of good things are planned for the next few years. However, layers of complexity mean more risk, and it is increasingly difficult for even Ethereum developers to keep up with the pace of innovation. While Ethereum doesn’t need to be completely technically rigid, it eventually brakes a bit:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

To be fair, adding a zkEVM ER isn’t exactly like a walk in the park. However, they are, in my opinion, the last step in Ethereum’s ambitious roadmap, with the curve leveling off near the top of the graph. One day we will slow down, but not yet.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Overview of the main points

My favorite analogy is that ER is the public sector and SCR is the private sector. The SCR is still home to innovation and most Rollup activity. ER is the slow and stable predictable base layer on which to operate providing maximum security. The two coexist in harmony. ERs add far more value to SCRs than any marginal activity they cannibalize.

Ethereum already has a convincing plan for scaling DA. But that doesn’t mean it should settle for its settlement layer. Ethereum can and should compete here too. zkEVM ER provides the best way to scale L1 Ethereum, positioning it as the primary settlement layer.

ER maintains its trusted neutrality with Ethereum’s economic and social alignment, creating an incredibly cohesive system. A robust currency generates the next level of economic security, subsidizing the security of the entire ecosystem.

The only arguments against ER are ‘social’ arguments around neutrality and competition. While I understand these concerns, I think they are generally exaggerated. Ethereum should certainly pursue a zkEVM ER when the technology is ready and then evaluate parallel instances.

You don’t think Ethereum’s base layer will always be weak and throughput will always be low, right?

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Ethereum – settlement and data availability (DA) layer

Now that we have a better understanding of how these Rollups work, let’s go back to the base layer they actually need.

Data Availability (DA) is obvious – making it super cheap, offering a lot, making it easy to verify with DAS. Both Ethereum and Celestia aim to do this one way or another.

My general argument about settlement – I don’t think the best settlement layer will be limited to the core functionality of validating/arbitration proofs and bridging tokens. Ethereum should retain a rich general purpose local execution environment. This will be where the big DeFi will be, which are price-insensitive on a per-transaction basis. This provides SCR with huge network effects, liquidity, and built-in security.

Ethereum should have a long-term focus on how to scale the settlement layer (stateless, zkEVM).

DeFi pooling

Maybe some of you have private jets, but most of us fly commercial. I need to split the bill with other people. It’s a bit like DeFi pooling‌.

  • Decentralized liquidity is bad – so it’s better to concentrate liquidity in one place (like Ethereum).
  • But high fees are not good either – so do we need to break liquidity to avoid congestion?
  • No – we’re just flying commercial on L2.

If I want to deposit $100,000 into Yearn, a $10 fee is acceptable. But paying 10% as a fee for a $100 deposit doesn’t make sense. Instead, L2 can hold 1,000 people who want to deposit $100 into Yearn, tie them together, and make a single L1 deposit! All this without the user having to pay L1 gas fees – you only pay $0.01 of the fee share. In fact, this is exactly what Argent already provides via zkSync.

Aave is also exploring this as part of its deployment on StarkNet. They will develop a smart contract to aggregate L2 user deposits and deposit them into L1. This contract will distribute aTokens from Aave L1 to StarkNet users based on the user’s proportion in the pool. This contract will aggregate the user’s aTokens and deposit them into L1 Aave when the collateral is redeemed.

Here’s an oversimplified version:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Decentralized AMM (dAMM)

dAMM was first proposed last year by StarkWare in partnership with Loopring. I’ll summarize their designs here. However, please note that this is an active area of ​​research with open design questions. There is no live implementation yet, and future designs may look completely different from this.

dAMM is an L2 AMM that aggregates liquidity in a single L1 pool enforced by L1 contracts. Execution occurs on multiple ZKRs that share liquidity asynchronously. LPs serve L1 AMMs while participating in L2 transactions, exposing them to more transactions. (higher trading volume) / (same liquidity) = higher fee % → better capital efficiency.

Asynchrony = L2 s can process transactions without forced communication with other L2 s using the same dAMM L1 liquidity pool. This is the key to making shared AMM possible.

This is achieved by separating the liquidity pool from the pricing state. Because funding and state are decoupled, you can have multiple states (for multiple ZKRs) using the same liquidity pool. Each ZKR has its own dAMM state.

The contract agrees to offer whatever price the L2 state offers, as long as the L1 contract has sufficient liquidity to complete the offer. All states should revert to equilibrium ratios due to arbitrage.

This solves the main obstacle to sharing AMM between L2s – there is a concurrency risk if users can transact at the same time. Otherwise, this may make it impossible for each L2 to know if it can safely complete the settlement.

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Impermanence Loss (IL)

LPs face greater IL risk in dAMMs – the risk grows linearly with the number of markets the LP is exposed to. Thus, in the worst case, LPs suffer n times the IL they suffer under the regular UniswapV2 AMM. This doesn’t matter for stable currency pairs (eg, in Curve), but can be high for other pools. This can be mitigated using a parameter in the smart contract called the dAMM “health factor”, which limits the possible loss of the maximum IL LP. This health factor ensures that the dAMM liquidity ratio does not drop too low.

L1 <> L2 synchronous transaction

This design can support multiple independent markets on L1 and L2, all of which share the same liquidity. L1 liquidity (e.g. traded on Uniswap) can be used as dAMM liquidity by allowing L1 LP tokens (e.g. from UniSwap ETH/DAI) to be deposited directly into the corresponding pool (e.g. ETH/DAI) on dAMM.

dAMMs can support L1 transactions, but the health factor can no longer be easily mitigated. However, LPs can choose to take this additional risk and expose themselves to L1 transactions.


Vitalik has made his thinking clear that sharing a DA layer with settlement is really tricky:

Delphi Digital: The Complete Guide to Rollup Part 2 - Ethereum Rollup Stack

Much of this goes back to Vitalik’s famous post on why the future is multi-chain rather than cross-chain. Roughly speaking, a trusted pairwise cross-chain bridge means a 51% attack on the connected chain = your bridge is attacked (many bridges are actually worse). Similar principles apply if you settle in Ethereum but publish your data elsewhere (eg, in Celestium). If Celestia gets a majority here, you’re out of luck again.

A Rollup that shares the DA and SL avoids these problems because they create a trust-minimized bridge between each other (it’s also possible to use a DA-only trust-minimized bridge without a shared SL, more on that later). If Ethereum isn’t 51% attacked, you can’t 51% attack Rollup alone. Even if Ethereum suffers a 51% attack and reverses transactions, its Rollup will be reversed and the two will remain the same. Therefore, you can safely hold assets published on one Rollup and wrapped on another Rollup.

So sharing a DA and settlement layer can provide the best security. But if you decide to use Ethereum as a settlement layer and then provide another DA source (eg volition like zkPorter, validium, celesium, etc.), what are the benefits/tradeoffs? You can still use the same bridges and connections to L1 as any rollup – you share liquidity, DeFi pooling, etc. For volition, off-chain (eg zkPorter) and on-chain (eg zkSync) DA modes share the same state and are fully composable. You only have to choose at the user level when you want your data to be stored on-chain or off-chain.

Settlement alone provides network effects to a large extent, while DA adds overall security. These network effects can be safely optimized by sharing DA. For example, you can more easily implement burning and minting mechanisms across Rollups, allowing you to natively deploy tokens across chains. However, with very different trust zones, it won’t be so easy.

Ultimately, we can see that there is a safety margin here. Many Ethereum Rollups, validiums, etc. will use Ethereum for settlement – but not all of them will use their DA. DA is at least somewhat more commoditized, and it will be a rich resource.


This is the biggest wild card of how strong the different layers of network effects are. The reality is that we’re still incredibly early in understanding how rollups will communicate with each other in the future, which could have meaningful implications for how these stacks play out. There are a lot of theoretical possibilities, a lot of unsolved problems, and a lot of hard engineering problems. For example, Slush is working on some of the most exciting bridging possibilities for ZKR. In the future we may see atomic composability between ZKRs.

Posted by:CoinYuppie,Reprinted with attribution to:
Coinyuppie is an open information publishing platform, all information provided is not related to the views and positions of coinyuppie, and does not constitute any investment and financial advice. Users are expected to carefully screen and prevent risks.

Like (0)
Donate Buy me a coffee Buy me a coffee
Previous 2022-08-06 10:20
Next 2022-08-06 10:22

Related articles