Radix Review 2024: Addressing DeFi's Pain Points

The challenges facing decentralized finance (DeFi) platforms, particularly those hosted on Ethereum, are multifaceted and significant.

Ethereum's poor scalability has led to exorbitant transaction fees, hindering the usability of DeFi and potentially deterring users from Ethereum-based DApps. While Ethereum 2.0 aimed to address scalability issues, its full implementation is still a couple of years away, necessitating interim solutions.

Proposed solutions include leveraging Layer 2 networks and exploring alternative blockchains with higher throughput and multi-chain support. However, transitioning DeFi platforms to these alternatives poses development challenges and requires interoperability solutions to maintain token parity across blockchains.

Radix is a blockchain network with only one thing in mind: improving the DeFi experience for everyone. As this Radix review will cover, every component of the Radix stack — spanning from the execution environment and programming language to the transaction model and wallet — is crafted to facilitate the secure creation, storage, and interaction with native assets.

Radix Review Summary

Radix addresses the critical challenges of DeFi by introducing a highly scalable blockchain network specifically tailored for decentralized finance while ensuring interoperability with established blockchains. Additionally, it incentivizes continuous and professional development efforts.

The Key Features Of Radix Are:

• Radix Wallet
• Radix Engine
• Scrypto
• Self-Incentivizing Developer Ecosystem
• Unlimited DApp Scalability
• Cerberus Consensus Algorithm

What is Radix?

Radix is a platform designed for managing digital assets securely. These assets, called resources, are treated like real-world objects. They can be created, stored, and exchanged in a way that's easy to understand and interact with, similar to physical items. This system ensures that users can trust how assets behave without needing to understand complex code.

In Radix, smart contracts are split into two parts:

• Blueprints are like templates that define what a component can do and how it manages its data.
• Components are instances of these blueprints, each with its own unique data but following the same rules set by the blueprint.

This approach encourages developers to create modular and reusable code, similar to how building blocks can be combined to create different structures. Plus, developers can earn rewards whenever others use their blueprints or components.

Unlike other platforms where transactions are limited to calling methods on smart contracts, Radix transactions involve a series of steps called a transaction manifest. This manifest describes exactly what needs to happen for the transaction to succeed, including calls to different components and passing data between them. Everything in a transaction either happens all at once or not at all, ensuring consistent and predictable outcomes. Users can also add their own guarantees to transactions, giving them more control over the process.

Radix uses a role-based access control system for security. Instead of basing access on who or what initiated an action, developers define roles and rules about what those roles can do. Actors need to prove they have the necessary roles (using "badges") before they can perform certain actions. Developers have control over these roles, deciding whether they can be changed or not. This model separates access rules from business logic, making applications more flexible and secure.

How Radix Aims to Fix DeFi

Radix is eliminating the technological obstacles that impede the growth of DeFi by directly meeting the demands of DeFi on a global scale for the next 100 years. Here's how:

Asset-Oriented Smart Contract Paradigm

While DeFi is revolutionary, beneath its surface lies a web of technological challenges that threaten to stifle its growth and potential impact on global finance. At the heart of these challenges is the inadequacy of current smart contract paradigms, epitomized by the Ethereum model that emerged in 2013.

In the early days of Ethereum's inception, the notion of DeFi at a global scale was not yet fully realized. As a result, the foundational principles upon which Ethereum's smart contracts were built did not anticipate the complexities and demands of modern DeFi applications. Fast forward to the present day, and we find ourselves grappling with the consequences of this mismatch between technological capabilities and market needs.

One of the most glaring issues plaguing current smart contract development is the steep learning curve associated with languages like Solidity, Ethereum's primary programming language. Mastery of Solidity to a "DeFi ready" level often requires years of dedication and practice, severely limiting the pool of developers capable of building sophisticated DeFi applications. Even seemingly straightforward tasks, such as creating a token, necessitate the deployment of custom smart contracts from scratch, leaving developers burdened with the responsibility of implementing basic functionalities themselves.

The current paradigm also places an overwhelming emphasis on security, forcing developers to spend a disproportionate amount of time safeguarding their applications against potential exploits. Despite their best efforts, vulnerabilities persist, resulting in frequent DeFi hacks and irreparable financial losses. This cycle of vulnerability and exploitation is not merely a reflection of developer incompetence but rather symptomatic of fundamental flaws within the existing development paradigm.

Fundamentally, every DeFi application revolves around the management of assets and the enforcement of authorization protocols. However, the current smart contract paradigm offers little in the way of support for these crucial aspects, leaving developers to navigate treacherous waters without a safety net. As a result, even the most well-intentioned efforts to build production-ready DeFi applications often devolve into sprawling, unwieldy codebases that are rife with potential vulnerabilities.

Radix proposes an alternative approach: an asset-oriented smart contract environment and programming language designed explicitly for the demands of modern DeFi.

Radix Engine

Radix is revolutionizing smart contract development by introducing an asset-oriented paradigm through its Radix Engine.

Unlike traditional approaches where assets are managed at the smart contract level, Radix integrates assets as a fundamental feature of its platform. This means that tokens are not implemented through separate smart contracts but are directly requested from the platform itself, streamlining the process and ensuring consistency.

In Radix Engine v1, tokens are treated as "physical" objects held within user accounts, offering a more intuitive and user-friendly model. The platform enforces correct token behaviour through a well-constrained finite state machine (FSM) model, minimizing errors and ensuring reliability.

Radix Engine v2 builds upon this asset-oriented approach by introducing decentralized computation capabilities, allowing developers to write powerful smart contract logic using Radix's programming language, Scrypto. Additionally, Radix Engine v2 expands on the concept of tokens with a more versatile form called Resources.

Compared to the Ethereum Virtual Machine (EVM) model, Radix's approach drastically simplifies smart contract development, reducing code complexity and mitigating common issues like reentrancy. Radix smart contracts, referred to as components, offer clearer functionality, modularity, and composability, resembling reliable machinery rather than intricate code.

Furthermore, Radix promotes modularity and reusability through on-network blueprints, which serve as templates for useful functionality that can be instantiated into components.

Scrypto

Radix's Scrypto language is designed to complement the Radix Engine by providing developers with a programming language that aligns with the platform's asset-oriented paradigm. Based on Rust, Scrypto retains most of Rust's features while incorporating specific functions and syntax tailored for Radix Engine v2.

In Scrypto, assets like tokens and NFTs are treated as platform-native resources rather than being implemented as smart contracts. These resources can be created using built-in functions, specifying parameters such as supply and name. When created, these resources are stored in temporary containers called buckets, which are then transferred to more permanent containers called vaults.

Smart contract logic in Radix Engine is designed around resources and vaults. Components define the data they hold and the methods they offer, with each method containing the component's logic and serving as its interface to the external world. Components are instantiated from blueprints, which act as templates for creating multiple instances of components.

Scrypto offers several benefits, including simplified smart contract development, direct interactions with assets, and enhanced safety and flexibility in authorization mechanisms. With Scrypto, developers can focus on writing core business logic rather than deal with development issues.

On-Network DeFi "Lego Bricks"

The Radix platform introduces the concept of the Blueprint Catalog, which revolutionizes the way developers access and utilize pre-existing tools, libraries, and frameworks for building DApps.

Traditionally, developers rely on open-source methods and community collaboration to discover and use pre-existing solutions. However, with Radix Engine operating on a decentralized network, developers can now leverage community collaboration and package manager-like functionality directly onto a common network.

The Blueprint Catalog provides an on-network mechanism for Scrypto Blueprints to be modularly used, leveraged, updated, versioned, extended, and combined. This empowers developers to directly incorporate operational and proven pieces of Blueprint-based functionality within the shared computing environment on the network. Deployed Blueprints not only contribute indirectly to the developer ecosystem but also directly extend the available functionality of the Radix platform.

This system allows developers to contribute to the ecosystem by creating Blueprints that excel in performing specific tasks. These Blueprints can serve as de facto standards of the platform, accelerating development and promoting interoperability among DApps. The philosophy behind the Blueprint Catalog aligns with the Unix philosophy of "writing programs to do one thing well" and "writing programs to work together."

The Blueprint Catalog integrates this philosophy into its deployment and usage, offering a platform feature that streamlines access to functionality created by others. Developers can quickly instantiate Components from a universal on-network Catalog, ensuring ease of access, safety, and transparency. Additionally, Blueprints support versioning, allowing developers to update and revise their functionality while maintaining compatibility with existing components and blueprints.

Self-Incentivizing Developer Ecosystem

The introduction of the Developer Royalty System on the Radix platform represents a significant innovation aimed at incentivizing developers to contribute to the ecosystem. Building on the concept of economically self-incentivized open networks pioneered by blockchain, Radix extends this incentive structure to developers through the Blueprint Catalog and associated mechanisms.

The Developer Royalty System allows developers to specify royalties for each usage of their Components or Blueprints in transactions. Unlike traditional app stores, where users pay for access, royalties are paid on a per-transaction basis, ensuring that payment is based on the real utility that the Component or Blueprint brings to the network.

Developers can set different royalties for various types of usage, such as Component use and Blueprint use, tailoring their pricing to suit the nature of their offerings. This system creates a direct developer-to-developer marketplace for useful functionality within a decentralized environment.

The Radix protocol automatically calculates and enforces royalties, guaranteeing payment through consensus mechanisms. The Developer's Guide provides a convenient interface for developers to discover and integrate Blueprints and Components, facilitating the growth of the ecosystem.

Unlimited DApp Scalability

The challenge of scalability in decentralized ledger technology (DLT) platforms, particularly those focused on DeFi, is evident with Ethereum nearing its limits due to the rapid growth of DeFi applications.

While many DLT platforms propose higher throughput as a solution, simply achieving high transactions per second (TPS) doesn't fully meet DeFi's scalability needs. To serve as a global finance platform, scalability must include unlimited throughput of transactions, DeFi DApps, and atomic composability between DApps.

Radix addresses these requirements through its Cerberus consensus algorithm, tightly integrated with the Radix Engine application environment used by DApps. We'll explore Cerberus in the next section but here is a top-level view of its key features:

• Atomic Composability
• Unique Sharding Approach
• Dynamic Scalability

Radix Engine, integrated with Cerberus, optimizes DApp throughput by treating tokens as global objects, specifying transaction intent rather than specific substates, and assigning each smart contract to a single shard for efficient processing.

In essence, Radix's approach offers unlimited parallelism for both tokens and DApps while maintaining atomic composability, essential for scaling DeFi to the level of global finance.

Radix Cerberus

As the DeFi ecosystem experiences growth, scalability has emerged as a paramount concern. The rapid proliferation of DeFi applications has pushed existing infrastructure to its limits, highlighting the need for solutions capable of addressing the scalability bottleneck.

Enter Cerberus.

While traditional approaches to scalability often prioritize increasing transactions per second (TPS), Cerberus recognizes that achieving true scalability in DeFi necessitates a more nuanced approach. Mere speed alone cannot adequately fulfil the diverse and complex requirements of decentralized finance.

Instead, Cerberus embodies a holistic vision of scalability that encompasses not only throughput but also atomic composability, dynamic sharding, and efficient consensus mechanisms.

Unlike traditional consensus mechanisms, which operate within isolated shards, Cerberus employs a braiding technique to intertwine consensus across multiple shards within a single transaction. This ensures that transactions involving multiple DApps or assets can be executed atomically, without the need for complex cross-shard coordination. By synchronizing consensus across shards, Cerberus mitigates the risk of double-spending and ensures the integrity of the network.

Here are some of Cerberus' top features:

Atomic Composability

At the core of Cerberus lies its approach to atomic composability — the ability to ensure seamless interoperability between DApps and assets. In the context of DeFi, atomic composability refers to the capability of composing a single transaction involving multiple autonomous smart contracts. This enables the execution of complex financial operations, such as decentralized exchanges and lending protocols, in a single atomic step.

By preserving atomicity, Cerberus eliminates the risk of partial execution or inconsistent states, thereby enhancing the efficiency and reliability of DeFi transactions.

Unique Sharding Architecture

Cerberus introduces a sharding mechanism that deviates from conventional static shard configurations. Unlike traditional approaches, which partition the network into fixed shards, Cerberus supports a practically unlimited number of shards, enabling transactions to span multiple shards seamlessly.

This dynamic sharding approach is essential for accommodating the diverse and evolving needs of decentralized applications. By distributing computational load across a multitude of shards, Cerberus ensures optimal resource utilization and scalability without compromising atomic composability.

Dynamic Scalability

Cerberus offers linear scalability through unlimited parallelism, allowing the network to process a vast number of transactions and DApps simultaneously.

This dynamic scalability is crucial for accommodating the ever-growing demand for DeFi services and applications. As network activity surges, Cerberus adapts dynamically, allocating computational resources efficiently to meet the needs of users and developers alike.

Radix Wallet

The traditional approach taken by many wallets involves integrating application features directly into the wallet interface. While this approach aims to provide convenience, it often leads to compromised user experiences and raises questions regarding trust and ownership.

Consider the analogy of a bank app that attempts to include a shopping interface within its platform instead of offering a charge card. This scenario would raise concerns about the bank's motives, the limitations of the shopping experience, and the user's control over their finances. Similarly, when crypto wallets integrate features like decentralized exchange (DEX) swaps or fiat onramps directly into their interfaces, users may question the wallet's impartiality and whether certain applications are being favoured for business reasons.

Also, the integration of application features into wallet interfaces can result in bloated user interfaces and limited functionality. Users may find themselves navigating through cluttered screens or encountering compromised versions of application interfaces within the wallet. Additionally, the inclusion of built-in features may create confusion about ownership and control over digital assets, undermining the principles of decentralization.

The non-custodial Radix Wallet offers an alternative. Here are some of the wallet's features:

• The Radix Wallet separates core functionality from application interactions, ensuring users maintain full control over their digital assets.
• Smart Accounts eliminate the need for a single seed phrase, enhancing safety and simplifying crypto management.
• Personas enable easy logins to DApps while preserving identity and preferences.
• Users can share multiple accounts with DApps simultaneously, facilitating seamless transactions across different accounts.
• Identity is decoupled from asset ownership, allowing personalized interactions with applications without compromising privacy or security.
• Radix's transaction protocols ensure transparency and security, empowering users to verify transaction outcomes independently.

DeFi on Radix

Radix's DeFi ecosystem is very small compared to many other protocols, but it has been increasing lately.

DefiLlama ranks Radix as the 51st largest protocol by TVL, which stood at $49.3 million as of March 28. Just two weeks ago, however, Radix's TVL stood at  $21.5 million as of March 12.

DefiLlama lists six DeFi DApps on Radix, four of which are DEXes.

With a TVL of $41.3 million, CaviarNine is the largest DEX on Radix. It boasts 778 tradeable tokens and a total volume of $229 million.

XRD Token

XRD is the native token of the Radix Public Network. XRD serves two main purposes:

• Staking: XRD is crucial for Radix's delegated proof of stake (DPoS) system, which protects the network from Sybil attacks. In this system, XRD holders stake their tokens to vote for validator nodes. These validators, selected based on their delegated stake, secure the network and receive rewards.
• Transaction Fees: XRD is used to pay transaction fees on the Radix Public Network, primarily to prevent spam transactions. Half of the base network fee is burnt, ensuring a secure and sustainable network.

XRD Tokenomics

XRD has a maximum supply of 24 billion tokens:

• 12 billion tokens were allocated at the beginning of the Radix Public Network. Of these, 9.6 billion are circulating, and 2.4 billion are locked in the stablecoin reserve.
• An additional 12 billion XRD is being created by the Radix Protocol over about 40 years to reward stakers and validators. This emission started when the Radix Public Network began in July 2021.

12 billion XRD tokens (50% of the max supply) were issued at the genesis of the Radix Public Network in July 2021. This is what the allocation looked like at the time.

XRD's current price represents a decline of 87.5% from its all-time high of $0.6513, which it achieved in November 2021.

Where To Buy Radix XRD?

You can buy XRD on centralized exchanges like Bitget, Gate.io and MEXC. Also, check out our picks for the best crypto exchanges.

For those interested in decentralized exchanges, XRD can be bought via CaviarNine and DefiPlaza, which is a DEX on Radix. You can also head over to our article where we highlight the best decentralized exchanges.

Staking XRD Tokens

Staking fosters decentralization, bolsters security, and optimizes the performance of the Radix Public Network.

At its core, staking on Radix involves users delegating their XRD tokens to validator nodes. These nodes are tasked with verifying transactions and upholding consensus on the network. Through delegated proof of stake (DPoS), tokens staked to validator nodes determine their likelihood of participating in transaction validation and consensus. Essentially, the community, represented by XRD token holders, is instrumental in selecting the validator nodes that oversee the operation of the Radix Public Network.

The DPoS mechanism not only facilitates decentralization but also safeguards the network against potential security threats while optimizing its overall performance. By actively participating in staking, members of the Radix community contribute to the ongoing stability and reliability of the network.

Moreover, economic incentives are intricately woven into the Radix Protocol to incentivize both XRD token holders and validator node operators. These incentives come in the form of newly minted XRD tokens, referred to as emissions. Emissions are distributed to stakers and node operators based on their active participation in transaction consensus. This incentivization mechanism ensures that stakeholders are duly rewarded for their contributions to the network's integrity and functionality.

How to Stake XRD Tokens?

Staking XRD tokens demands thoughtful consideration. It necessitates careful deliberation in selecting trustworthy and reputable validator nodes to delegate one's stake to. Diversification of stakes across multiple node-runners is also recommended to mitigate risks and uphold network resilience.

Upon staking, participants receive Liquid Stake Unit (LSU) tokens directly from the Radix Protocol. Unlike traditional staking mechanisms, LSUs remain unrestricted and can be seamlessly exchanged within Radix's DeFi ecosystem, offering stakeholders liquidity and flexibility.

For those seeking to unstake their tokens, the process entails a waiting period of approximately seven days, equivalent to 2,016 epochs. This grace period ensures a smooth transition while maintaining network stability.

How to Stake on Radix:

• Go to the Radix dashboard and click on "Network Staking" on the left side.
• You'll see a list of all the validator nodes on the Radix Network.
• Choose one or more validator nodes you want to stake your tokens to.
• After selecting, click on "Stake to Selected." This will take you to another screen called "Add Stake."
• Here, pick the account you want to stake from and enter the amount you want to stake.
• You can choose to split your stake equally among the validators by toggling a switch or manually entering the amount for each validator.
• Review the total stake amount and then click "Send to Radix Wallet."
• In your Radix Wallet, you'll see a screen to review the transaction. Scroll down and use a slider to sign the transaction.
• Once done, the Radix Dashboard will show you the validator information you've staked to.

How to Unstake on Radix:

• Go to the Radix dashboard and select the Validator node you want to unstake from.
• On the Validator information screen, find the Stake amount section and click "Request Unstake" below it.
• Enter the amount you want to unstake and click "Send to Radix Wallet."
• In your Radix Wallet, review the transaction on the "Review Transaction" screen. Scroll down and use a slider to sign the transaction.
• Keep in mind there's an unstaking delay of 500 epochs, roughly 10-15 days. After this period, your tokens will be available in your wallet.

Note that once you request an unstake, you'll stop earning rewards for that stake starting from the next epoch. However, you'll still earn rewards for the current epoch.

Radix Roadmap

In this section, we will delve into the journey of Radix through its major milestone releases, from the genesis of Olympia to the groundbreaking advancements of Babylon, and look forward to the promising developments anticipated with the upcoming Xi’an release.

• Olympia (July 2021): This was the starting point, the birth of the Radix Public Network and its native token, XRD. Olympia laid down the basic framework for future developments. It introduced the Radix Engine v1, which allowed token transfers and creation without complicated custom coding. The consensus protocol, Cerberus, was introduced in a simplified form to prevent Sybil attacks. Olympia boasted features like low fees, fast transactions, and quick finality times.
• Alexandria (December 2021): Alexandria aimed to equip developers with tools for building DeFi (Decentralized Finance) DApps on Radix. It introduced Scrypto, Radix's own programming language, and Blueprints and Components in the Radix Engine v2. Developers got a safe environment to experiment with Scrypto development before deploying on the mainnet.
• Babylon (September 2023): Babylon marked a significant upgrade, bringing the Radix full stack to life. It introduced the Radix Wallet, designed for easy and secure user experience in Web3 and DeFi. Scrypto and Radix Engine v2 made development intuitive and secure, even for those with minimal coding experience.
• Xi’an (Upcoming): Xi’an is the next big step in Radix's journey. It will introduce the fully sharded form of the Cerberus consensus protocol, aiming for infinite scalability and unlimited composability. These features are crucial for DeFi to handle the needs of billions of users in the future.

Radix Review: Closing Thoughts

Radix aims to revolutionize DeFi by addressing the critical pain points and challenges faced by existing platforms. Through its innovative approach and robust infrastructure, Radix offers a highly scalable blockchain network specifically tailored for DeFi, ensuring interoperability with established blockchains while incentivizing continuous development efforts.

The comprehensive suite of features offered by Radix, including the Radix Wallet, Scrypto programming language, and Cerberus consensus algorithm, demonstrates its commitment to providing a seamless and secure DeFi experience for users and developers alike. By focusing on asset-oriented smart contracts, modular development, and a self-incentivizing developer ecosystem, Radix sets a new standard for decentralized finance, enabling unlimited scalability, atomic composability, and dynamic sharding capabilities.

With its roadmap set for further advancements, such as the upcoming Xi’an release introducing fully sharded consensus protocol, Radix continues to pave the way for the future of DeFi, poised to meet the demands of global finance for the next 100 years and beyond.