The Discrepancy between Centralized and Decentralized Exchanges
In today’s blockchain landscape, centralized crypto exchanges are one of the most widely used infrastructure platforms (along with wallets) that enable the onboarding of large numbers of users.
However, centralized exchanges (CEXs) are almost exclusively built as central limit order books (CLOBs), which present as a list of buy and sell orders through a user-interface. Generally, these orders are filled based on price-time priority, meaning that the highest bid and lowest offer are filled first, therefore incentivizing market makers to compete to provide the best prices possible.
The end result is a system that has a very small discrepancy between the bid-ask spread, allowing buyers and sellers to obtain the best price possible (with minimal slippage) when filling their order. This incentives market makers to send a large number of fresh orders to an exchange in a given time period.
Conversely, decentralized exchanges (DEXs) typically make use of the automated market maker (AMM) model, as was initially introduced by Uniswap in 2018. Exchanges like Uniswap and others become well-known as the pioneers that built DEXs using the AMM bonding curve formula x*y=k. AMMs allow users to swap from one asset to another via two separate liquidity pools. For example, when a user holds USD coin (USDC) and wants to swap it into ether (ETH), their swap exchanges USDC from a larger USDC liquidity pool for ETH located within a larger ether pool.
As a significant advantage over centralized exchanges, DEXs allow users to connect their non-custodial wallet directly with the exchange, placing users in full control of their funds while transacting. This is in contrast to centralized exchanges where the user must trust the entity behind the exchange to safeguard their funds.
More importantly, AMMs are susceptible to capital inefficiency. Case and point, typically when users transact on an AMM they provide liquidity (into a liquidity pool) within a specific price range which can be comparatively narrow or as wide as the range from 0 to infinity. Regardless, capital inefficiency exists.
Within narrow ranges, a large percentage of the capital is actionable (usable to conduct a swap) when the price is in range, but this occurs infrequently. Conversely, when liquidity is deposited in wide price ranges, capital is spread out significantly and most if it is not actionable at a specific moment in time.
Because asset prices are continuously changing, capital is only efficient on an AMM when liquidity providers (LPs) employ tight ranges and repeatedly update those ranges. Despite this approach, frequent updates require significant gas (the fee the network charges to send a transaction) on Ethereum, meaning providers only update their ranges occasionally because they are sometimes required to pay substantial gas fees.
Consequently, this capital inefficiency can mean significant slippage for users, especially when it comes to larger orders. The larger the order relative to total liquidity, the more slippage occurs, which is also compounded by the prevalence of shallow liquidity pools.
The solution to the host of issues we discussed above is to create a decentralized limit order book (LOB) where users can reap the benefits of both centralized and decentralized exchanges on one platform. This would mean users could manage their funds securely through their own non-custodial wallet (such as MetaMask, Trust Wallet, or Keplr) while also benefiting from better asset pricing (with minimal slippage) typically present on centralized limit order book exchanges like Binance, Coinbase, or OKX.
This balancing act that offers the best of both worlds is one of the biggest challenges Monad is trying to solve. That said, this is no easy feat. To build a truly decentralized limit order book exchange, the underpinning technology must be extremely scalable and decentralized. Thankfully, Monad’s protocol is built to be inherently decentralized and its hyper-scalable design is focused on matching or surpassing the likes of Solana and others.
Monad: A Scalable Next-Generation EVM Layer 1
Monad is a Proof of Stake (PoS) Ethereum Virtual Machine (EVM)-compatible Layer 1 smart contract platform that combines extreme performance and decentralization as a proprietary solution to address the blockchain trilemma.
Monad’s Ethereum-compatible design allows developers to port their applications to and from Monad, greatly simplifying the development of Ethereum-focused dApps and protocols that can be deployed on the platform.
This is extremely important because most networks focused on scalability and high transaction throughput within the current blockchain landscape are not Ethereum compatible, not to mention the fact that a fully on-chain EVM-compatible limit order book exchange is meant to dramatically alter how users trade and invest in the asset class moving forward.
One of the main defining characteristics of Monad is a scalability framework that harnesses blazing-fast parallelized superscalar pipelining architecture to process transactions in an extremely fast manner. This design allows the network to employ a staggered approach rather than carrying out single processes one after another, greatly enhancing overall network throughput.
In addition to its highly scalable architecture, Monad is designed to be composable (compatible), permissionless, and censorship-resistant in nature. Of great significance, composability is a characteristic that allows for the seamless connectivity of various types of protocols, dApps, and smart contracts to create new and highly complex functionalities through various integration types. Examples of applications and protocols that could be connected in this manner include DEXs, decentralized money markets, perpetual futures platforms, and the like.
Programmable composability dramatically increases compatibility and interoperability for developers and the applications and protocols they build, not only within the Monad network, but with external chains like Ethereum and various types of middleware tooling systems (e.g., oracles, wallets, one-click deployment solutions, and API frameworks).
In terms of scalability, the Monad blockchain makes use of a wide range of technical innovations that allow the protocol to achieve both 1 second block finality and 1 second block time to realize a throughput of 10,000 transactions per second (TPS). These include:
- MonadBFT - allows the protocol to achieve agreement on arbitrary payload under partially synchronous conditions as it maintains byzantine fault tolerance (in-protocol security)
- Deferred Execution - as a significant optimization to achieving consensus by eliminating execution from the hot path of consensus (while employing superscalar pipelining)
- Carriage Cost and Reserve Balance - a specialized transaction pricing model that defends against spam and potential attacks on the network
- Shared mempool a framework that allows transactions to be referred to by hash and propagated via the mempool prior to actually being sent to eliminate network lag
- Parallel Execution - enables execution via a mechanism using parallelization that allows for the concurrent processing of a large number of transactions via separate cores, dramatically improving the protocol’s performance and scalability
- a customized database used to store the blockchain’s state, enabling the system to process transactions exponentially faster
Monad History and Background
Monad was founded in early 2022 by several American computer engineers. After one year of development in February 2023, Monad closed a 19-million dollar seed round led by Dragonfly Capital. The round also included contributions from Placeholder, Lemniscap, Shima Capital, Finality Capital Partners, and various crypto angel investors including Naval Ravikant (the co-founder of AngellList), 0xMaki (the former founder of SushiSwap), and Chris Burniske, the former head of crypto at ARK Invest.
On February 14th, 2023 Monad announced it had raised a total of 19 million from various venture capital firms and private investors. (Image Credit: Monad Labs via the Monad Twitter channel)
Monad is headed by co-founder and CEO Keone Hon, co-founder and CTO James Hunsaker, and co-founder, COO, and Head of Business Development, Eunice Giarta. All three founders have a background in high-frequency trading (HFT), building trading algorithms, and similar disciplines, hence the reason for the project’s focus in these areas.
Keone Hon attended the Massachusetts Institute of Technology (MIT) between 2007 and 2011, earning a Bachelor of Science in Computer Science and Mathematics, later completing his Masters in Finance, Engineering, and Computer Science.
After his post secondary studies, Hon spent 9 years working for Jump Trading and Jump Crypto and spent 2 years with KCG Holdings prior to being brought on by Jump. His positions at these firms focused on the development of quantitative trading strategies as a software engineer; and later, in management running a team of computer engineers focused on related disciplines.
Eunice Giarta also attended MIT between 2009 and 2013, graduating with a Bachelor of Science in Computer Science and Engineering and a minor in Management Science and Finance. Giarta then went to on the work at several firms including Shutterstock, Broadway Technology, and Bank of America Merrill Lynch in various positions. These included product development, business development, senior product manager, payments product lead (licensing and payouts), rates derivatives trading, and more.
James Hunsaker spent 8 years at Jump Trading between 2014 and 2021. James’ time at Jump was spent mainly as a senior software engineer focused on crypto trading and the development of high frequency trading (HFT) algorithms and systems.
Prior to his time at Jump, James worked for 4 years at Goldman and Sachs and J.P. Morgan where he began as an associate and later as a vice president focused on creating advanced trading algorithms, electronic market making, EQ volume automation, and the like. Prior to his finance and computing career, James studied computer science and mathematics at the University of Iowa for several years.
Monad Use Cases
Although Monad has many utilities, as we touched on initially, one of the main use cases for the platform is to create a parallelized hyper-scalable protocol that allows users to make use of a decentralized limit order book exchange on top of the Monad network.
This would allow users to solve the exchange dilemma between decentralized exchanges and centralized exchanges, enabling users to securely hold their assets in a non-custodial wallet, while also eliminating the slippage typically incurred on DEX platforms, providing users with a CEX-like trading experience.
Relatedly, with the new generation of crypto, one of the most important use cases is the ability to swap from one asset to another within a non-custodial wallet.
This is especially important because this functionality could eventually eliminate the need for centralized crypto exchanges if a user is able to swap from one token to another directly in their wallet. Though a possibility, centralized exchanges and decentralized exchanges will likely always have a place in the industry. That said, they are surely not the be-all end-all.
In this context, the front-end (what the user sees during interaction) of a wallet user interface (UI) is difficult to build correctly, but pales in comparison to the complexity of creating the back end. The back-end of a wallet swapping interface takes into account a vast interconnected network of market makers, liquidity providers, oracle data feeds, and much more.
It is extremely complex to distribute the liquidity needed for each token in a specific wallet so that hundreds of thousands or millions (and eventually hundreds of millions) of users are able to conduct a swap from one crypto asset to another. Completing swaps in larger crypto assets like Bitcoin and Ethereum is much simpler than swapping between smaller tokens with much less liquidity.
At this time, there are many wallets across the industry that allow for in-wallet asset swapping. The main issue with these services and DEXs is slippage.
The higher the slippage (usually between 1% and 5%), the more capital is lost when trading between assets. This slippage discrepancy between decentralized exchanges, and even within non-custodial wallets, is one of the main challenges that Monad is meant to address.
Because the chain is largely designed by developers of low-latency and high-frequency trading systems, its speed and low-gas design will go a long way to eliminating slippage and egregious waiting times, not only in wallets, but within DEXs and numerous trading alternatives of all shapes and sizes.
In addition to its trading and decentralized limit order book exchange focus, the Monad blockchain has the potential to fulfill a wide range of use cases for retail and enterprises such as those focused on payment settlement, remittances, stablecoins, and NFTs.
Depending on its direction long-term, some of the potential enterprise use cases for Monad include FinTech, big data, cybersecurity, artificial intelligence (AI), insurance, supply chain management, and logistics. The Monad platform may one day also be focused on a vast number of applications in energy, healthcare, pharmaceuticals, art, entertainment, agriculture, automobile, e-governance, and decentralized identity (DID).
The Benefits of Layer 1’s vs. Layer 2’s
Throughout the past several years, and more so over the past year, many blockchain iterations are being launched as rollup-focused Layer 2 networks.
Many of these platforms are designed to scale Ethereum by increasing its transaction throughput and reducing gas fees needed to send transactions on the network. This trend is likely here to stay in the short- to medium-term as evidenced by the large number of major players launching Layer 2’s in 2024.
However, Layer 2 network’s are susceptible to numerous challenges. Therefore, Monad chose not built their platform as a Layer 2 rollup because of three main reasons:
Monad believes that decentralization and censorship resistance are non-negotiable when developing any blockchain system.
Layer 2’s typically lack a mechanism that enables decentralized block production, an essential component required to ensure true decentralization and censorship-resistance of a network.
Most Layer 2’s rollups are centralized because they rely on a centralized sequencer (a larger single node) to produce blocks on-chain, which in turn possesses all-encompassing authority to choose the network’s transaction order and censor transactions.
Firstly, overarching control of transaction ordering gives the sequencer the ability to extract value from propitious ordering, whether directly; by inadvertently favoring its own transactions, or indirectly; by accepting payments from arbitrageurs.
Secondly, the wherewithal to censor transactions means that the sequencer is able to deny service to applications, protocols, or users should it choose to. This is not simply an abstract consideration, but can actually be implemented in practice. For example, centralized authorities (e.g., the foundations or entities behind the network’s development) who have overreaching control over the sequencer could potentially enforce arbitrary blacklists.
The central control of Layer 2 sequencers has been a point of heavy discussion of late. Notable Layer 2 rollups such as Arbitrum, Optimism, Starkware, and others have been known to postpone decentralizing their sequencer for extended periods of time, highlighting the challenges Layer 2’s face with centralization.
In summary, Monad was not built as a rollup because the Monad team feels that decentralized block production is of utmost priority. Centralization compromises crypto and the ethos of blockchain, while simultaneously creating central points of failure both technically and as a leverage point for centralized entities.
Monad is designed to be as performant as possible. This design makes use of a pipelined execution structure, scheduling transactions in a parallelized manner across numerous cores, with forthcoming transactions scheduled successively. In addition, transaction execution is expedited significantly by making use of a custom storage backend for state and contract code.
These innovations make nodes operating on Monad extremely efficient compared to the majority of mainnet nodes and rollup nodes in existence. These design choices may still cause readers to wonder why Monad was not built with these improvements as a standalone rollup in its own right. Let’s get into it.
By way of illustration, unlike Layer 1’s, Layer 2’s don’t make use of a consensus mechanism and are operated by a central sequencer that is responsible for block production. Typically, rollups maintain their own state within a merkle-trie, but must commit data to a data availability (DA) layer (generally Ethereum). In addition, rollups employ a proof mechanism that guarantees that the merkle root matches the outcome of applying transactions in a sequential manner.
This ultimately means that rollups are highly dependent on their data availability layer because transaction ordering on the DA layer determines the true verifiable state of the rollup. This highlights part of the tradeoff: rollup sequencers are centralized and could potentially go offline at any instance (e.g., solar flares, lightning strikes, network malfunctions etc.). In the event that the worst-case scenario should occur, the DA layer would be required to arbitrate the ownership of all assets (tokens, NFTs etc.) held on the network. Because of this fact, the data availability layer should be considered the true authority of the network.
Essentially, when arbitrarily comparing a rollup to an independent Layer 1, its evident that rollups are designed to eliminate consensus overhead, while carrying out execution in a more centralized manner, thereby relying on their proof mechanisms to ensure that merkle roots stored on the decentralized DA layer accurately represent the outcome of the correct transaction order that was appended on-chain. This model extenuates several ‘advantages,’ most notably:
- Because there is no need for direct decentralization, the sequencer runs on expensive hardware such as a super-computer with a huge amount of RAM
- Consensus generally requires a substantial portion of block time, resulting in significant limitations on the execution budget. Alternatively, a blockchain controlled by one node (i.e., a sequencer) does not experience the same overhead
As a consequence to this centralized design, the rollup is heavily reliant on its data availability layer. More specifically, the rollup is responsible for the cost of pushing transaction (transaction gas costs on Layer 2’s can be very expensive) data and merkel roots back to the DA layer, while also inheriting capacity limitations and poor time to finality from the DA layer.
With Arbitrium and Optimism, for example, carrying out simple swaps is 20x cheaper than on the Ethereum mainnet. Despite this being a significant improvement, Monad is designed to surpass this exponentially to offer 1000x the throughput and be 1000x cheaper.
Instead of eliminating consensus from its design, Monad developed a novel BFT algorithm complimented by a high-performance peer-to-peer (P2P) layer. In this design, Monad
implements a modular design whereby nodes come to consensus prior to execution, allowing execution to run in parallel, somewhat deferred, thereby utilizing the full block time.
These improvements allow Monad’s highly-performant consensus to provide the best of both worlds: consensus is able to keep up with execution rather than hindering it, while the network doesn’t inherit unsustainable costs or constraints from the data availability layer.
Monad asserts that a high-performance EVM execution environment that has the ability to be used by anyone at any time is vital to massively improving the adoption and utility of decentralized computation. Monad believes that unrelenting focus is needed to solve some of the most challenging problems that currently present themselves in the crypto sphere.
Blockchains represent a decentralized framework focused on maintaining a collective global state through the trustless execution of transactions. Therefore, blockchains are extremely powerful because they enable a large range of applications, protocols, and assets to coexist within a singular environment, enabling atomic composability and accelerated innovation.
Within a decentralized system, computation is realized through a large number of nodes operating in parallel who systematically verify the legitimacy of each other’s operational processes to make sure that state transitions (continuous changes on-chain) are followed correctly. This facilitates trustlessness (not having to trust another entity to ensure the desired result is obtained) throughout the network, ultimately extenuating the blockchain to serve as the backbone of a vast interconnected universe of use-case-specific applications.
Fundamental to this all-encompassing system, is the verifiability of the network’s computation via its users. The innately requires the blockchain software to be extremely efficient computationally, or for transaction throughput to be extremely restricted, allowing users to make use of the chain via commodity hardware.
Monad monumentally improves the efficiency of computation, extending an environment that supports a vast number of users and an increasingly complex breadth of applications of all shapes and sizes, while at the same time, allowing users to run computation locally.
This is accomplished via Monad’s pipelined transaction execution — which allows for transaction processing in parallel across an interconnected number of cores — and by massively improving state and contract storage via a customized backend. This improved efficiency is a prerequisite of undeniable algorithm improvements as opposed to reliance on hardware (like in many Layer 2 systems).
All blockchain types, whether rollup or another iteration, must focus on improving execution throughput. This is because the only solution to preserve rollup state integrity is to ensure that all rollup blocks are appended to execute all required transactions needed to make continuous state updates.
Monad’s mission is to continue to materially advance execution throughput in blockchain systems to help realize a new era of EVM in the blockchain arena.
- Published on