The Monad Thesis

Breaking the EVM Speed Barrier with 10,000 TPS.

One of the standout ideas in the blockchain space that has received substantial market validation is the concept of a general-purpose execution environment that allows full composability between all applications.

Ethereum L1 first introduced this concept, quickly gaining a huge market approval.

Building on this success, Solana integrated parallelization into its execution engine, achieving up to 100 times the throughput of Ethereum L1 with fast finality.

This was also a huge success!

Now, Monad is merging EVM, the most widely adopted VM in this space, with the concepts pioneered by Solana, aiming to achieve 1000x Ethereum L1's throughput.

Could this make Monad a "runaway success" and one of the biggest launches of this cycle?

So, let's go.

EVM and The Power of Global State

The Ethereum Virtual Machine (EVM) is a global computing engine. In this system, numerous nodes operate in unison, each maintaining a complete and consistent copy of the entire network, including all applications and their current states. This setup ensures that all nodes are synchronized and process transactions uniformly.

To interact with applications on Ethereum, users send transactions to the network. These transactions, which are essentially function calls to smart contracts, are grouped into blocks. Every node processes these blocks in the same sequence, which helps the network remain synchronized.

The Power Of The Shared Global State

The EVM provides a single, shared environment where all smart contracts and applications coexist and can freely communicate with each other. Any application built on the EVM has access to all the data and functionality of other applications on the network.

For example, a DeFi lending protocol can easily integrate with a decentralized exchange to allow users to seamlessly trade their borrowed assets.

This is possible because the EVM standardizes how apps run and keeps track of all accounts, balances, and codes. Developers can build apps that work with this existing system without needing special setups; they simply interact with other smart contracts already in place.

Such flexibility, often called "composable money legos," allows developers to treat various protocols as building blocks that can be assembled in creative ways to unlock new use cases.

Specifically, the EVM gave Ethereum the first-mover advantage by being the first blockchain platform to enable full composability between all applications in the system.

To give you some perspective, this is how successful the EVM has been so far:

Total Value Locked (TVL): 

EVM-based chains dominate the TVL metrics. According to data from DefiLlama, as of May 2024, EVM-based chains hold 89.48% of the total TVL in the blockchain ecosystem.

Developer Adoption:

From a developer adoption perspective, EVM platforms are the most popular. If you look at the top 10 ecosystems with the most number of active developers, 6 of them are EVM-based.

Key findings from Electric Capital's report on the state of development within the Ethereum network and other EVM chains during the fourth quarter of 2023 show that a significant majority of multichain developers, approximately 9 out of 10, choose to work on EVM-compatible chains.

Both these metrics highlight EVM’s continued dominance in attracting developer talents.

In essence, EVM has established significant network effects in the blockchain space, but it is not the most performant or the most secure VM out there, and this is slowing the pace of innovation that could have been achieved otherwise.

Single-threaded Nature: EVM’s Achilles heel

In modern computing, performance gains are often achieved through parallel processing, where multiple computational tasks are carried out simultaneously. Since the EVM processes transactions sequentially, it cannot leverage multi-threading or multi-core processing effectively. This single-threaded design inherently limits the throughput of the system as the transaction load increases.

The EVM design sets a gas limit on blocks, capping the computational work per block. Each transaction uses gas based on its complexity, limiting the number of transactions per block.

Sequential processing exacerbates this limitation because only so much work can be queued and processed within one block's gas limit.

The inability to parallelize transaction processing means the EVM does not fully utilize available computational resources, thereby limiting overall performance.

To put it simply, most blockchains that support the EVM bytecode standard can process up to ~200 transactions per second (TPS) or ~20 million transactions per day, which is not enough for high-demand applications.

That's where Solana introduced its VM, which pioneered parallel execution and proved a point!

Solana Proved A Point

Solana pioneered parallel execution through Solana Virtual Machine (SVM), which includes the Sealevel parallelization engine.

Transactions on Solana are required to explicitly declare all the states they will read or write during execution. This includes specifying all the accounts and data that the transaction will interact with.

By making these requirements explicit, Solana's runtime can easily identify dependencies between transactions and determine which ones can be executed in parallel.

This setup is a part of Solana's Sealevel system, which is the world's first parallel smart contracts runtime. Sealevel allows thousands of smart contracts to run in parallel, maximizing throughput and efficiency across the network.

With the explicit state declaration and Sealevel’s capabilities, Solana's runtime can identify transactions that are independent of each other, meaning they do not read or write to the same state. These independent transactions can then be executed in parallel, significantly increasing the throughput of the network.

In addition, Solana improves its parallel processing by allowing concurrent transactions that read from the state as they do not modify the state and cause conflicts.

Since these transactions do not modify the state, they can be executed simultaneously without causing conflicts, further enhancing the network's capacity for parallel processing.

These innovations collectively enabled Solana to achieve a throughput of 500–1,000 TPS, excluding votes.

SVM + EVM = Monad

The primary approach behind Monad is quite straightforward. Monad adopts the parallel execution model pioneered by Solana, allowing multiple transactions to be processed concurrently to significantly enhance the performance and security of an EVM-compatible blockchain.

So what are the core concepts of Monad's architecture?

Pipelining

Monad implements pipelining, which involves dividing transaction processing into stages and executing the stages of each transaction in parallel with other transactions. Monad is integrating here a modular approach in designing an L1 blockchain.

Here's how it works:

Monad breaks down the processing of each transaction into distinct stages, such as fetching the transaction data, verifying signatures, executing the transaction, updating the state, and committing the results.

For example, while one transaction is in the execution stage, another transaction can be in the signature verification stage, and yet another can be in the data fetching stage.

By executing stages of different transactions simultaneously, Monad makes efficient use of available resources (such as CPU cores and I/O bandwidth). This is analogous to the laundry example, where the washing machine and dryer are used concurrently to process multiple loads of laundry more efficiently.

Although the stages of transactions are processed in parallel, Monad ensures that the results are committed in the original intended order. This preserves the correctness and consistency of the blockchain state.

By overlapping the execution of transaction stages and utilizing resources efficiently, superscalar pipelining dramatically improves the overall throughput of the Monad.

Optimised Consensus

MonadBFT

MonadBFT is a high-performance consensus mechanism designed to achieve agreement on transaction ordering under partially synchronous conditions.

It is a derivative of the HotStuff consensus protocol, incorporating improvements proposed in Jolteon/DiemBFT/Fast-HotStuff.

It is a two-phase pipelined BFT algorithm that leverages optimistic responsiveness and has linear communication overhead in normal conditions, falling back to quadratic communication complexity in the event of a leader timeout.

In each phase, the leader sends a signed message to voters who then sign responses to the next leader.

This pipelining allows the quorum certificate (QC) or timeout certificate (TC) for a block to be included with the proposal for that block.

A quorum certificate indicates that two-thirds of the network's validators agreed to append the block, while a timeout certificate indicates that the consensus round timed out and had to be restarted.

This pipelined structure enables simultaneous processing of multiple blocks,

reducing delays and allowing Monad L1 to process transactions quickly and securely, even with a large number of validators in the network.

Yes, Monad can theoretically scale its validator number to hundreds and eventually to thousands of validator nodes.

Shared Mempool

Monad optimizes the consensus payload by referring to transactions by their hash and ensuring they are propagated through the Mempool ahead of time. This reduces the amount of data that needs to be included in the consensus process.

Deferred Execution

Monad separates the consensus process from transaction execution. Nodes first come to an agreement on the transaction order without actually executing those transactions.

This is different from Ethereum, where execution is a prerequisite to consensus and the leader and validating nodes must execute transactions before agreeing on a block. This pipelining allows consensus to proceed without waiting for execution to complete.

By decoupling execution from consensus, Monad significantly expands the time available for transaction execution. Execution merely needs to keep up with consensus on average, rather than fitting into a limited time window.

This allows for higher gas limits as computation doesn't need to be completed on all nodes within a strict budget.

Carriage Cost and Reserve Balance

Since consensus operates on a delayed view of execution, Monad introduces a carriage cost for transactions to prevent spam. Each account maintains a reserve balance to pay for the carriage cost of in-flight transactions.

The carriage cost is charged to the reserve balance at consensus time, deducted from the execution balance during execution, and refunded to the reserve balance after a delay period. This ensures that only paid transactions are included in blocks.

Efficient Execution Environment

Optimistic Execution

At the core of Monad's Parallel Execution model is the principle of optimistic execution. This means that Monad begins executing transactions before the completion of previous transactions in the block.

This approach can sometimes lead to incorrect execution if, for example, two transactions modify the same account balance in ways that would conflict if executed sequentially.

To address this, Monad employs a mechanism to "merge" the updated state from each transaction sequentially, ensuring that the final state is consistent with a sequential execution order.

Monad also employs techniques to avoid unnecessary re-executions when possible, such as dependency analysis to identify transactions that can safely run in parallel, and caching of loaded state data to speed up re-execution.

MonadDb State Backend

Enabling optimistic parallel execution requires a high-performance database to store the blockchain state. Monad uses a custom database called MonadDb that is optimized for this purpose.

MonadDb leverages asynchronous I/O to allow for concurrent execution while data access is in progress. It fully utilizes the latest kernel support to achieve high-performance asynchronous operations.

This parallel execution model, combined with MonadDb's optimized data access, allows Monad to achieve significantly higher transaction throughput compared to sequential execution, while still guaranteeing correct results that match the expected sequential behavior.

EVM Compatibility

​​Monad is fully compatible with EVM bytecode, allowing smart contracts written in Solidity or any other language that compiles to EVM bytecode to run on Monad without alterations.

Developers can transfer their existing Ethereum contracts to Monad smoothly, benefiting from its high performance without the need to rewrite their code.

Furthermore, Monad fully supports the Ethereum RPC API. This compatibility enables existing tools, wallets, and applications designed for Ethereum, such as MetaMask, Etherscan, and Hardhat, to operate on Monad without any adaptations.

By maintaining this level of compatibility, Monad ensures that the extensive Ethereum infrastructure is available to its users, simplifying the transition for developers and users alike.

What about all the hacks? Isn't EVM broken from a security perspective?

Yes, from a security perspective, the EVM is currently compromised. The overwhelming scale of on-chain exploits and asset losses has significantly hindered the mainstream adoption of blockchain-based solutions, particularly in DeFi, over the past few years.

Here's what the numbers show:

Total DeFi Losses:

EVM vs Non-EVM Losses:

It's hard to see how EVM-based DeFi could become mainstream given the current situation. However, all hope is not lost for EVM. Monad is also enabling developers to make EVM more secure than it is now.

Let's go into the details here:

Security Is Costly on Ethereum

On Ethereum, implementing robust security measures in smart contracts can be very costly due to the high gas prices associated with additional safety checks and computations.

To reduce gas costs, developers often forego additional safety checks, compromising security for efficiency.

Here Are Some Examples of Gas Optimizations Compromising Security:

Limiting Defensive Assertions:

  • Defensive assertions are checks that programmers include in their code to ensure that certain conditions always hold during the execution of smart contracts.

  • They are essential for preventing exploits, especially re-entrance attacks, where a contract may be manipulated into a vulnerable state without triggering any alerts.

  • Developers may omit additional defensive assertions, especially with evolving code, to reduce gas costs.

Tricks for Gas Savings: 

  • Saving gas by using advanced Solidity features or unconventional coding practices often results in less legible and more complex code. 

  • This complexity can obscure the code's function, making it harder for other developers and auditors to review, thus increasing the likelihood of oversight and errors.

Minimizing On-Chain Interactions: 

  • Practices like requesting infinite ERC-20 token approvals from users to reduce gas costs compromise security by potentially allowing attackers to drain user funds if the app is compromised.

  • With approximately $250 billion secured in ERC-20 tokens and NFTs on Ethereum, the implications of compromised security are immense.

Cost-Effective Security

By drastically lowering the cost of gas, Monad makes it financially feasible for developers to include comprehensive security measures in smart contracts.

This reduction means that developers no longer need to make trade-offs between security and cost-efficiency, and can focus on employing the best practices.

Additionally, by reducing the cost barrier, Monad allows for the implementation of more complex and inherently secure protocols that would be too gas-expensive on Ethereum or other EVM-based L1s or L2s. This includes more advanced state management techniques, and integrated error-checking mechanisms.

Monad’s economic model also makes it feasible to implement continuous integrity checks and monitoring systems within smart contracts, which can alert developers and users to anomalous behaviors indicative of breaches or bugs.

You also need to keep this in mind: While you can directly port over your EVM contracts, you won't gain any security benefits.

To fully benefit from the low-cost execution environment and create more secure applications, you cannot simply copy and paste the existing code.

Instead, you must make changes to enhance security, which essentially results in altered code that then requires re-auditing.

But would these optimizations make the Monad version of the EVM the most secure VM out there?

It's highly unlikely because new-generation VMs like Move are far ahead in terms of enabling secure coding, but the Monad EVM could very well be the version that enables the most secure EVM-based application, and that's a big upgrade from the status quo!

But why not be an Ethereum rollup?

The core focus of Monad is to maximize performance and scalability without compromising decentralization and censorship resistance. Taking the rollup path would be a serious roadblock to achieving that goal.

Let me explain:

Decentralization and Censorship Resistance

Current roll-up designs do not have a fully decentralized block production mechanism. They depend on a centralized sequencer to order transactions, creating a central point of control and potential censorship risks.

Although there is ongoing research aimed at decentralizing sequencers, achieving this is unlikely in the near to medium term.

By developing Monad as a layer-1 blockchain that employs a proof-of-stake Sybil resistance mechanism with a decentralized network of validators, the system is designed from the start to maintain decentralization without inheriting the limitations of an existing layer.

Performance and Scalability

Monad's custom architecture is built from the ground up for ultra high-performance transaction execution with the pipelined execution model to efficiently process transactions in parallel across multiple cores.

As a layer-1, Monad can make radical optimizations to its consensus mechanism, peer-to-peer networking layer, and storage layer to minimize overhead and maximize throughput.

Implementing these major architectural changes to push the boundaries of performance would be much more challenging, if not impossible, within the constraints of a rollup design built on an existing layer-1.

Avoiding Data Availability Layer Limitations

Another key factor is the limitations and dependencies that rollups inherit from their data availability (DA) layers.

Rollups rely heavily on their DA layer for state verification and data availability. This introduces constraints around transaction costs, capacity, and time to finality.

As an independent layer-1, Monad has more control over its transaction costs and capacity. It is not beholden to the limitations of an external DA layer.

What Is With the Monad Memes?

The crypto market is very noisy mainly because DLT is a future-oriented technology. Currently, no blockchain-based applications have user numbers comparable to popular web2 applications. Therefore, every team building an L1 or a rollup is creating their solution for the future.

This results in a high volume of competing narratives, each seeking attention and influence. These narratives shape public perception and influence investment decisions because a leaderboard exists in the blockchain space, with CoinMarketCap acting as a leaderboard of blockchain tokens.

Websites like CoinMarketCap rank cryptocurrencies and tokens based on market capitalization, price changes, and trading volume, creating a leaderboard format.

It's undeniable that there is a sentiment that if a L1 blockchain or an application is lower down this leaderboard, these projects or L1s are considered less significant, even if it has nothing to do with the technological fundamentals of this project.

Look at bitcoin, the "digital gold" narrative has captured the imagination of a significant number of people and made it today a 1.2 trillion dollar asset. If you look at the meme coin action right now, you will also see that memes are powerful tools that can capture value

In effect, narratives and memes are powerful tools that could help projects climb the leaderboard ladder and gain maximum exposure. As they say in the crypto space, "numbers going up is the best marketing you can get.", and Monad is leveraging all those tools to create hype for the project.

Monad's current engagement figures are comparable to some of the top 10 L1’s (based on CoinMarketCap). This is already a great success from a community-building and marketing perspective. And if you look a bit deeper, this comes as no surprise.

Looking at Monad's backers, you'll find some of the biggest names in the blockchain space who understand how the crypto markets work.

This explains why Monad has almost perfected the crypto marketing game. In a market where meme coins outperform L1 tokens with strong fundamentals, community building and spreading the message through memes is a perfect strategy.

Winding Up!

Looking at the Ethereum L1, it is clear as a day that the focus is no longer on scaling the core idea that gave Ethereum the first mover advantage in the firstplace.

i.e, "A general-purpose execution environment that allows full composability between all applications"

It's focused on becoming the global settlement layer, an idea which has not yet received any serious market validation.

The other EVM-based L1s are mostly seen as copy-pastes of Ethereum L1 and lack the grand vision and narrative to aim at what Monad is trying to achieve.

If you look at the Ethereum L2 ecosystem, the protocols have to deal with the current limitations of Ethereum DA to providing a cheap execution environment or have to depend on centralized sequencers, compromising censorship resistance which is the core philosophy of DLT.

At the same time, Solana, with the current real throughput limitation around 800-1000 tps, limits the capabilities of Solana to keep up with the increasing demand, and it can take a while until Solana brings the next upgrades to improve throughput.

In this situation, Monad is on its path to fill the gap in the market by bringing 10x more than the current throughput of Solana and also using a VM that has the most developer adoption in the whole blockchain space. Along with that, Monad has already built a huge active community.

The biggest bet Monad is making is on the staying power of EVM.

Right now, this would seem like the right thing to do but at the same time we are watching the rise of more secure and efficient VMs like Move, and in a scenario where blockchain-based systems have achieved little to no real-world adoption, betting on the staying power of EVM is a big risk that the Monad team is taking.

Could that happen and could Monad be irrelevant in the next 3-4 years of years' time?

We don't know that yet, but one thing for sure, Monad is on its way to be one of the biggest L1 launches of this cycle, and with the recent success of Monad devnet, things are working in favor of Monad.

Do you like our Thesis Approach to understanding crypto and blockchain tech?

Then Subscribe to our Newsletter and we'll deliver a Thesis every week straight to your inbox:

Guaranteed spam-free:)

DISCLAIMER: None of this is financial advice. This newsletter is strictly educational and is not investment advice or a solicitation to buy or sell assets or make financial decisions. Please be careful and do your own research.

Reply

or to participate.