Radix is the only real solution to DeFi’s issues — here’s why.
The DeFi industry is growing. It’s maturing. It currently has $6.4Bn of assets in the system (that’s up from $2.5Bn in the last 30 days).
Yet with every step forward comes more strain on the Ethereum network. Transaction fees become even more unsustainable, and with every new DeFi application, there are new security risks, audit requirements, and even higher barriers to entry for new developers.
This isn’t anyone’s fault, Etherum was just never designed to serve the needs of DeFi, and as a result, it is constraining the growth of the industry. That is the reason Radix is building a layer 1 protocol that is built specifically for DeFi — DeFi is the future of finance, and Radix will be the future of DeFi.
However, Radix isn’t the only protocol working towards this goal, there are various approaches to tackling different issues facing DeFi. While each has their merits, in this article we are going to look at how Radix compares in the two main areas that DeFi is currently experiencing the most growing pains on Ethereum; Scalability & Development Ecosystem (security).
Scalability and Composability
If you have tried to use a DeFi application (or the Ethereum network in general) lately, you may have noticed that the gas fee of transactions has increased… a lot!
A sudden increase in gas has made many transactions too expensive to be viable. If you take a quick look on social media, you will see many examples of $30+ gas fees just to do a swap on uniswap. This is clearly not a sustainable level and makes all but high-value transactions impossible.
Scalability is the solution, and sharding is a common method proposed to achieve this. However, there is one small problem…..
Ethereum 2.0, Polkadot, Avalanche, Near, Cosmos break DeFi Composability!
A bold claim, but in an attempt to solve just one of the major problems facing DeFi (scalability), these alternatives all use types of sharding as solutions to scaling that break a key feature of DeFi: atomic composability. The ability to stitch together multiple functions from multiple dApps within a single atomic transaction is critical for DeFi. A great example would be simultaneously lending from one dApp, while borrowing in another. While this process is easy without sharding (and is already utilised), most sharding approaches break this functionality by separating applications onto shards that cannot act in concert in a single step.
Radix is the only protocol that uses sharding to deliver linear scalability — without breaking composability. This means that Radix can meet the throughput needs of any number of dApps as the network grows, and all of those dApps can continue to interoperate without limitation.
As you can see in the table below, Radix (using our Cerberus sharded consensus protocol) is the only solution that provides the scalability DeFi requires, while maintaining unlimited atomic composability. Other proposed protocols who offer improved scalability either provide limited composability across select applications or completely break composability by separating each application on its own side-chain.
If you want to read more about how Radix maintains unlimited atomic composability while still scaling, our Cerberus Whitepaper goes into the full details.
However, don’t just take our word for it. The Radix team has been working with Professor Mohammed Sadoghi and his ExpoLab team at the University of California Davis. Together they have rigorously analyzed and tested Cerberus in a wide range of scenarios, as well as developing the mathematical proofs around Cerberus to guard against edge cases. They have even released a full academic paper on the subject here.
Having a protocol able to scale while maintaining composability offers little value if there aren’t applications for users to interact with running on it. This is where part two comes in.
Building an Ecosystem: Fast, Secure & Incentivised Development
Solidity is the programming language used to build smart contracts on Ethereum. It has been around for many years and has a large community of developers, both professional and hobbyist. Smart contracts on Ethereum are adaptable and powerful, allowing developers to build complex dApps for a wide variety of uses. In many ways, this is great.
Unfortunately, the level of flexibility offered by Solidity on Ethereum has drawbacks; complex code is challenging to write while avoiding errors and can result in unexpected outcomes or even catastrophic failure. Even over the last few weeks in DeFi, there have been serious problems (including loss of funds) caused by errors in smart contracts. In addition, this is made even more complicated when considering how “correct” code will behave when composed with other smart contracts. This is not only an issue for users but also for other developers who may leverage another dApp in their own dApp.
Due to the immutable nature of DLT’s, if there is an error, it cannot always be fixed. This means there is significant pressure for developers to ensure their code is functional and secure at launch. For example, many users (and developers) are reassured by code audits, but these only reduce the risk of issues rather than eliminate it. Likewise, spending more time on the code or getting more experienced developers also reduces risk, but still doesn’t eliminate it. All these steps mean it takes longer to develop code, while making it harder to build on top of the existing ecosystem and, outside of hobbyist development, significantly increases the cost of even doing relatively simple things.
Building a reliable financial application is a very different problem than building a game, web service or other general application. DeFi applications are specialized, and developers should use specialized development environments for such tasks.
The Radix Engine is our solution. Built specifically for DeFi applications, the Radix Engine enables secure development by using finite state machine “Components” rather than Turing complete smart contracts. You can read more about that here.
While security is paramount, development also needs to be fast due to the pace of innovation in the space. As we have discussed above, typical smart contracts are complex and it is a critical issue that must be tackled by the protocol directly. All Radix components are deployed into a component “catalog” where they can act as configurable universal features of Radix for any developer to access via simple API call. This allows developers to make use of proven, existing work by others, and to use components provided by Radix to create simple financial components (like Continuous Function Market Makers and much more) instantly.
Being able to quickly develop secure DeFi apps is great; but to build a thriving ecosystem, there need to be commercial incentives to build. This is the final (and often) underlooked piece of the puzzle. The typical solution is for the protocol to create a “developer fund” that hopefully gets a bootstrapped ecosystem up and running. The problem here is two-fold: what happens when the fund runs out, and how are the developers participating also aligned with adding long term value to the ecosystem?
Radix solves this issue with our on-ledger developer royalty system. Any Component a developer contributes to the catalog can include a custom “fee” that is added to transactions each time it is used. The developer can even set different fees according to how it is used. This means if a developer creates a useful (even a simple) component and assigns a small fee for each use, they can earn long term, recurring revenue for their work. This makes Radix a decentralized marketplace for DeFi utility, whether simple useful functions or full apps. To our knowledge, Radix’s Developer Royalty System is unique. You can read more about it here.
Combined together, and as you can see in the table below, Radix (via the Radix Engine) is the only solution for DeFi developers that provides a fast, secure and incentivised environment where they can thrive.
DeFi is experiencing exponential growth, and rightfully so. To facilitate this growth, DeFi needs to be built on a protocol that enables fast and secure development of commercially viable applications, at scale, while maintaining composability.
Individually those challenges are hard to overcome, combined, even more so. That is why we believe Radix is the only solution that ticks all the boxes.
Find out more in the Radix DeFi Whitepaper here.