Decentralized Scalability Will Be the Next Big Web3 Challenge: Here’s How We Fix It
Web3 is widely touted as a vision of a future, decentralized internet that’s based on blockchain technology. Proponents say it will lead to a more democratic internet ecosystem powered by decentralized applications, tools and services, in which people can take back control of their data and regain their freedom.
It’s a vision that many analysts agree with. In a recent report, Vantage Market Research projected that the market for Web3 services is expected to grow at a compound annual growth rate of 41.6% from 2022 through to 2028, from an estimated worth of $2.9 billion now to more than $23.8 billion at that time.
It’s an optimistic forecast that assumes Web3 will continue its already very rapid expansion, attracting more investment from venture capitalists and generating greater interest in concepts such as cryptocurrency, decentralized finance, the metaverse and play-to-earn games. If Web3 is to do this, it’s going to need to overcome what looks to be an insurmountable challenge that no project has yet been able to solve – the problem of decentralized scalability
The Difficulty Of Scaling Web3
Web3 has a scalability problem that will prove to be a major impediment to more widespread adoption, and if it’s ever going to become a multi-billion dollar industry as the most optimistic forecasts show, someone will need to come up with a solution.
The issues with blockchain scalability first came to light in 2016 with the explosion of interest in one of the first blockchain-based games, CryptoKitties.
CryptoKitties is a game hosted on the Ethereum blockchain that involves breeding digital kittens, raising them and then exchanging them with others. It proved to be an incredibly popular game, so much so that it caused unprecedented congestion on the Ethereum network. That led to slow transaction processing times, which was bad enough, and sky-high gas fees, which was far worse.
The network became so slow and expensive that it became almost impossible to play CryptoKitties and it also had a knock-on effect on other Ethereum-based apps. Following some discussion, Ethereum co-founder Vitalik Buterin came to term the challenge as Ethereum’s “scalability trilemma”.
Blockchain networks are based on three core pillars – namely security, decentralization and scalability, but the way they are designed means that you must always prioritize two at the expense of the third.
To overcome this challenge, Layer-2 networks such as Polygon have emerged. They work by offloading transactions from the main blockchain to a second “sidechain”, where they can be processed more quickly. Then, only the final result of an entire batch of transactions is processed by the main chain, eliminating much of the network traffic. This helps to keep things under control.
Ethereum has come up with its own solution too, known as the Merge, which involved shifting from a Proof-of-Work consensus mechanism to Proof-of-Stake. However, while this will help to solve the problem of high gas fees by eliminating miners, it will do little to solve Ethereum’s and Web3’s scalability woes. The transition to PoS was supposed to coincide with a second upgrade that would enable “sharding”, where the network is split into multiple components in order to increase transaction throughput. However, that move has since been delayed, and will only come in 2023.
Even when sharding does arrive, it will only solve one part of the puzzle. Fact is, blockchains and Web3 cannot scale by increasing transaction throughput alone, because this doesn’t do anything to improve atomic composability.
The Atomic Composability Problem
The need for atomic composability does not feature in many discussions about blockchain scalability but it’s an important consideration that cannot be ignored. That’s because it’s vital to ensure interoperability for Web3 applications.
Interoperability relates to a dApp’s ability to make use of multiple smart contracts to compose a single transaction. This is essential, because it means Web3 dApps can freely compose transactions across others. In this way, a DeFi app for example, can offer the most superior exchange rate across multiple decentralized exchanges. Alternatively, a DeFi app can leverage multiple crowdsourced liquidity pools to help traders spot and take advantage of arbitrage trading opportunities. These are both incredibly complex transactions that must all be carried out at exactly the same time in a series of complicated, “atomic” steps. This is necessary because each of these steps must be confirmed at once for the transaction to happen.
So without atomic composability, these kinds of use cases wouldn’t be possible in Web3. It’s a key capability of any blockchain that enables thousands of unique, interoperable dApps to work together.
Layer-2s and Atomic Composability Don’t Mix
Atomic composability is not a new idea. Indeed, Ethereum’s network supports hundreds of dApps that are already composable. The issue is that atomic composability on Ethereum’s network is highly inefficient, requiring that every transaction is processed via a slow-moving global consensus algorithm that cannot scale.
What’s more, while Layer-2 networks might speed up transaction throughput, they can only do this by sacrificing atomic composability. Ethereum’s Merge and Polygon both use a technique called “sharding”, which involves offloading transactions onto sidechains where they can be processed independently. The problem with doing this is that these independent shards are unable to communicate with each other until their bundles of transactions are finally committed to the main blockchain, meaning atomic composability becomes extremely inefficient.
Currently, cross-shard communication is performed using conditional cryptographic commitments, a technique that slows down transaction speeds, meaning that the network doesn’t benefit from the faster throughput.
A Radical Solution
The good news is that there is a solution that’s beginning to take shape. The Radix platform that’s built to support the next generation of highly scalable DeFi applications has created its unique Cerberus consensus mechanism that introduces an entirely new sharding technique. It’s a revolutionary design that can theoretically support an unlimited number of transactions and Web3 dApps that run in parallel to one another.
When designing Cerberus, Radix’s team realized three things. First, it recognized the need to support an unlimited number of shards so as to scale to meet the requirements of a truly global Web3 infrastructure that may one day replace the existing Web2.0 infrastructure. Second, Radix’s team also realized the need to conduct consensus on atomic transactions that can be synchronized only on those shards relevant to each transaction, so as to not congest the rest of the network. Finally, Radix also identified the requirement for an application layer that’s actually capable of utilizing this kind of “unlimited parallelism”.
Cerberus was therefore designed to support a limitless number of shards that are capable of reaching consensus in parallel, while also enabling consensus to be performed across any set of shards when relevant. In addition, it introduces the concept of “substrates”, which are a small record of a transaction with very specific rules, that can be assigned to any single shard to enable atomic composability.
As an example, a developer might want to create a token substrate to describe a straightforward transaction where Jack sends 10 XRD to his friend John. The substrate would take note that there are 10 XRD in John’s account, and that these are no longer in Jack’s account, to prevent any XRD from being lost or doublespent.
By using substrates to record the status of each token, Cerberus is able to process unlimited transactions in parallel. So it can support millions of tokens shared across millions of individual accounts, shared across as many shards as are required. Then, when someone wants to send tokens to another user, the two individual shards that store the information about who owns those specific assets will reach consensus together, but independent of the rest of the network, without impacting its performance. In this way, Radix enables atomic composability at an unprecedented scale.
To make all of this possible, Radix has created an entirely new application layer called the Radix Engine, which is not only able to define the meaning and rules of substrates, but also define which substrates should be included in the consensus. This ensures consensus is only conducted across the relevant shards. Ethereum’s EVM architecture is unable to support this, because all transactions must take place within a single timeline, a concept known as “global ordering”.
The key to nurturing the growth of Web3 is to protect its key pillars of tokenization, decentralization and atomic composability. If we take away any one of these elements by isolating dApps from one another through the use of techniques like sharding, it’s similar to isolating a bee from the plant it pollinates. This is visible in nature, where the human-enforced separation of flora and fauna has resulted in the unintentional destruction of entire ecosystems.
The same mistake cannot be made with Web3. As we strive to create a dynamic and flourishing infrastructure to support the next generation of the internet and global finance, the preservation of atomic composability is going to be essential for it to scale and thrive.Source