I have covered this topic ad nauseum, but I haven’t written a blog post summarizing the situation since Q3 2021. So, here’s an attempt at a somewhat concise summary of why rollups (and their disaggregated execution layer cousins like validiums, volitions, AnyTrust etc.) are orders of magnitude superior to monolithic blockchains - a true 1 to 100 innovation. I can write much more, but some of these points will be enough, for now. As always, I take a long-term view.
Consider this perspective: a rollup is but a monolithic blockchain, but one that’s tuned for the highest throughput. It just outsources security to a different layer who focuses on that. Ceteris paribus, a rollup necessarily offers significantly higher throughput than a monolithic blockchain - unless the monolithic blockchain is totally centralized. Now, different rollup implementations will have different characteristics, but fundamentally rollups are the ultimate throughput solution.
Rollups are the only solution to composability. You may have heard some claim that their one monolithic chain can replace vast swathes of the 100 million servers that run web2. This is delusional. Dragonfly has a very flawed analysis but one that still clearly shows one chain isn’t going to cut it, even assuming optimized cases in the future. So, it’s abundantly clear we need multiple chains.
Now, as mentioned above, monolithic chains have lower throughput than rollups, so they fragment composability much more significantly anyway. For example, where you need to fragment between a nightmare tangle of 1,000 monolithic chains, where each additional weak chain cripples the overall ecosystem. Instead, you can get away with 100 rollups. If these 100 rollups share a zone of security, then they are orders of magnitude less complicated and more secure to bridge between.
With secure access and synchronous calls to settlement layer, today’s ZK rollups already have DeFi Pooling, with greater possibilities like dAMM being explored.
But the greatest trick rollups can pull off is inter-rollup composability. Slush is a great proposal for how seamless fractal scaling between multiple zk rollups can work. We’re barely getting started here! At the endgame, it is possible one single zk rollup can be 10x faster than the fastest monolithic chain, and it can seamlessly, atomically compose with multiple other zk rollups sharing the settlement layer(s).
This one’s pretty simple - rollups can choose to inherit security from whatever the most secure settlement layer is. With side channels possible for transaction inclusion, they are practically as censorship resistant as the settlement layer.
Even alternate constructions like Arbitrum AnyTrust - which are better monolithic chains - are significantly more secure, as they have an honest-minority consensus. (E.g. in a monolithic blockchain with 1,000 validators, you’re assuming that 668 validators are right. With AnyTrust, you assume only 2 validators are right.)
Rollups have two ways to be highly decentralized and easily verifiable:
Likewise, rollups have secure access to liquidity to whatever settlement layer has the most liquidity. Even the perfect zk-bridge is vulnerable to 51% attacks on the weaker chain. An optimistic bridge could potentially thwart these, but adds an additional assumption and latency.
Let’s consider a monolithic blockchain that’s optimized for latency. It still needs to sync between all nodes, and either this takes time or finality is probabilistic. If this monolithic chain becomes a rollup, it doesn’t lose anything - it retains the same latency.
But rollups can go one further by disaggregation. Now, we have 2 tiers of latency - rollup confirmation and settlement finality. The rollup confirmation can be coordinated by a much smaller subset of nodes, hence improving latency. Further, fancy non-BFT / honest-minority consensus can come to finality much quicker. Rollup finality can thus happen at near the speed of light, while settlement confirmation as fast as the settlement layer. With recursive validity proofs, the rollup finality will be practically identical to settlement finality.
A rollup does not need to issue a token and build up its value - both contradictory - for high economic security. As a result, a rollup can be economically sustainable right from day 1, and be indefinitely sustainable. As long as there’s at least one sustainable settlement layer in the industry, they’ll be fine. It can issue a token, but this token can be used for other things, without being concerned about safety. There are ancillary benefits like a zk rollup where only one node needs to prove computations - which can have a significant economic benefit to expensive computations.
With the advent of interactive fraud proofs and validity proofs, rollups can be whatever they want to be. Unshackled from the very challenging work of security and liquidity, they can experiment with novel token models, user experience features like account abstraction, MEV mitigation, private smart contracts etc. Rollups can innovate rapidly at the execution layer, while having a safe-ish fallback.
Perhaps the greatest enabler is making application-specific paradigms. Smart contract chains are inherently inefficient. With fractal scaling solutions (see Composability section) enabling composability between rollups, application-specific chains are viable once again. I fully expect any applications needing high scale will simply deploy their own application-specific rollup, or network of application-specific rollups, to scale far beyond what smart contract chains can muster.
Deploying a rollup is far easier and safer than bootstrapping a token and validator set. Once rollup SDKs and sequencing services are easily available, it’ll be very simple indeed. StarkNet and zkSync 2.0 (and I’m sure others) are building turnkey L3 deployment solutions which makes it easier and cheaper still. There are intermediate solutions for monolithic chains like subnets (insecure) or parachains/shards (secure), but none of them can match the simplicity of deploying a rollup.
There is one main drawback:
Timing - To be clear, application-specific rollups are ready for primetime. These are the ultimate solutions to high throughput, already capable of outscaling smart contract rollups and monolithic chains alike. The final edge cases will be covered by the end of the year - see dYdX V4. However, smart contract rollups have more work to be done. We need zk provers to be distributed, and we need faster provers. Also, rollups need more activity for lower gas fees and faster batching. Fortunately, all of this is a matter of time with clear solutions in sight.
So, monolithic blockchains are still going to be relevant for the next year or so as rollups ramp up. That said, I’d argue that honest-minority L1s with rollup fallback like Arbitrum AnyTrust are a far superior solution in the interim, and that’ll be ready quite soon.
A lot of drawbacks often stated are not inherent to rollups, but to specific implementations. For example, enshrined rollups (i.e. L1 rollups) have exactly the same assumptions as the base layer.
Finally, there will always be niche applications where you don’t care much about security and just want to have complete sovereignty over the entire stack for technical or ideological reasons. In this case, monolithic chains still make sense. For everyone else, better focus on execution, settlement, or data availability, or be technologically obsolete soon. (In reality, marketing & cultism matter much more than tech in this industry, so it’s quite likely a handful of monolithic chains do well long enough to transition to the rollup-centric world.)