Published: July 23, 2024
Source: Sei V2 – Sei’s approach to scaling brings together the high-performance aspects of Solana and the network effects of the EVM
In today’s world we are accustomed to multitasking. Our computers effortlessly run processes in parallel, like listening to Spotify while browsing the Internet with dozens of open tabs. However, this is not table stakes for current blockchains, most of which operate in a surprisingly old-fashioned way – one transaction at a time. This sequential approach is a bottleneck for performance, hindering scalability and user experience.
Chains that support parallelization gain a competitive advantage because of their ability to process transactions concurrently, not having to wait for a process to finish before starting another. This drastically improves the performance of the network, allowing it to scale and handle the increasing loads and demand of on-chain applications.
The Sei V2 upgrade introduced the first high-performance parallelized EVM chain, and it is already live. Achieving a time to finality (TTF) of 380 ms it unlocks an entirely new design space that was previously inaccessible to EVM developers. Instead of having to learn the ropes of a new ecosystem like Solana, Aptos or Sui, EVM developers can now continue to take advantage of the developer tooling and network effects of the EVM. With Sei V2 it becomes possible to kick off the journey of building high-performance applications with orders of magnitude more throughput than some of the fastest L2s in the current market.
Sei, an open source general purpose Layer 1 (L1) blockchain, launched its V1 in August 2023 with the aim of becoming the fastest L1 for trading digital assets. To achieve this, it was optimized at every level of the stack to provide the best infrastructure for digital asset exchanges. Sei’s vision of “trading” includes a wide range of use cases such as trading tokens, NFTs, real-world assets, metaverse assets, risk, social-likeness, and more. Ultimately, the exchange of digital assets is the most fundamental use case of blockchains, and they wanted to build a chain that specialized on this basic primitive to enable the next generation of DeFi applications.
Figure 1: Digital assets trading: the fundamental use case of crypto
Source: Sei Blog
However, there were some challenges as a result of being a chain built on the Cosmos SDK, which forced both users and developers to learn the ropes of a new ecosystem. For that reason, and in less than a year of development, Sei V2 was envisioned to enable parallelization on the EVM. This would facilitate seamless onboarding for developers in order to leverage the network effects and mature tooling of the Ethereum ecosystem. The upgrade is already live, taking advantage of a first-mover advantage that will continue to receive new updates over time. This allows the development team to continue shipping new features while market participants don’t have to keep waiting for the release of other projects tackling a similar challenge like Monad or megaETH.
The team comprises professionals from Google, Goldman Sachs, Robinhood, Nvidia, and Databricks. The two co-founders, Jeffrey Feng and Jayendra Jog, bring diverse expertise, forging their entrepreneurial spirit in Silicon Valley. The former has a background in business administration with experience in investment banking and venture capital, while the latter has a technical background in Computer Science and has worked as a software engineer at companies such as SAP, Facebook, Pinterest, and Robinhood.
As of today, Sei has raised over $85M from investors including Multicoin, Jump, Coinbase Ventures, Flow Traders, Hudson River Trading, Bitget, Circle Ventures, other than leaders at Anchorage, LayerZero, and StepN. This took place over 3 funding rounds between August 2022 and November 2023 with the largest of them valuing the project at a $800 valuation.
Figure 2: Funding and Investors of Sei
Source: tracxn
Sei V1 was launched in August 2023 as an open source high-performance general purpose Layer 1 (L1) blockchain built on the Cosmos SDK and Tendermint Core. As an integrated blockchain, Sei combines the responsibilities of execution, settlement, consensus, and data availability into a single network.
Since inception Sei has stood out for its emphasis on speed, having the ambition to build infrastructure that could compete at feature-parity with large centralized exchanges, but with all the benefits that come with being a blockchain, such as decentralization, censorship-resistance, and permissionless access. In particular, Sei has aimed to address the performance issue that DEXs and high-performance DeFi applications face with current blockchain infrastructure. DEX platforms often struggle with limitations in the number of transactions processed per second (a.k.a. throughput) and the time it takes for a transaction to be considered complete and irreversible (a.k.a. time to finality), resulting in slow performance. This is a major problem for both high-frequency trading and high-volume trading activities.
Based on these premises, Sei V1 was built to optimize every layer of the blockchain stack specifically for digital asset trading, including token trading, NFTs marketplaces, gaming, and more. The main features that allowed Sei to achieve its goal are: (1) Twin-Turbo consensus mechanism, (2) transactions parallel processing, (3) order matching engine, and (4) native price oracles.
Sei relies on a Proof-of-Stake (PoS) protocol using a modified Tendermint consensus mechanism called the Twin-Turbo consensus. While Tendermint ensures transactions are finalized and irreversible with single slot finality, its 6-second block time was too slow for Sei’s needs. Hence, the decision was made to use a modified version of it, the Twin-Turbo Consensus, which has reduced block times to less than 400 milliseconds.
The performance increase has been achievable thanks to two key optimizations: (1) the Intelligent Block Propagation, and (2) the Optimistic Block Processing.
Intelligent Block Propagation improves efficiency as block proposers only transmit unique identifiers and hashes for transactions, allowing validators to quickly reconstruct blocks using their local mempool, reducing bandwidth and wait times.
Figure 3: Twin-Turbo consensus: intelligent block propagation
Source: Sei Blog
Optimistic Block Processing, rather than waiting for full consensus, reduces latency by enabling validators to start processing transactions as soon as they receive a block proposal, allowing steps to occur concurrently, leading to faster block validation and voting.
Figure 4: Twin-Turbo consensus: intelligent block propagation
Source: Sei Blog
In chains like Sei, which operate on the Cosmos SDK, validators follow a three-step process: “BeginBlock,” “DeliverTx,” and “EndBlock.” In order to achieve parallel processing, Sei customizes “DeliverTx” and “EndBlock”.
Instead of sequentially processing transactions in “DeliverTx,” Sei uses a Directed Acyclic Graph for simultaneous processing and conflict management. Additionally, Sei enables parallel order execution for independent orders tied to its native order-matching engine within the same block, with developers defining market dependencies.
Figure 5: Sei’s parallel transaction processing
Source: Sei Blog
As a result, Sei’s order-matching engine allows decentralized exchanges to create their own order books.
Sei integrates an order matching engine at the chain level, enabling developers to create order book-based exchanges on the Sei blockchain. This supports both central limit order book (CLOB) systems, used in traditional trading platforms and CEXs, and AMM systems, common in DEXs.
Transactions involving the matching engine execute atomically within a block. These transactions are directed to the DEX module, with each transaction potentially containing multiple orders. The DEX module’s EndBlocker hook consolidates these orders by market, resulting in a single smart contract call per market.
Figure 6: Order matching engine at the chain level
Source: Sei Blog
Sei further improves performance and user experience through order bundling: (1) transactions can include orders for multiple markets, reducing gas costs for market makers by directing orders to their respective smart contracts during block processing (client order bundling), and (2) orders across transactions are consolidated per market, requiring only one virtual machine instantiation, reducing latency by approximately 1ms per order (chain level order bundling).
Another functionality enables contracts to establish hooks within the network, triggering every block to facilitate actions like flash loan repayments and post-trade logic execution.
Thus, the matching engine provides a versatile interface, allowing DEXs to determine how assets are represented, without requiring direct token trading.
Lastly, Sei also counters maximal extractable value (MEV) with frequent batch auctioning, ensuring fair market conditions by consolidating and executing market orders at a consistent clearing price. This eliminates incentives for validators to manipulate transaction order, promoting a fair trading environment.
To facilitate asset pricing, Sei implements native price oracles. Validators act as oracles to ensure reliable and accurate pricing, with voting windows as short as one block for rapid updates.
During the voting window, validators propose exchange rates. At the end of the voting period, all votes are aggregated, and a weighted median (weighted by validator voting power) determines the accurate exchange rate. Penalties are imposed for non-participation and inaccurate data.
Validators are tracked by a miss count, which records failures to provide data or significant deviations from the weighted median. Exceeding a certain threshold within specified voting periods results in slashing penalties for prolonged misbehavior.
The above properties are highly relevant given Sei’s primary objective, which is to provide a high-performance, secure, and interoperable platform optimized for trading within the DeFi, NFTs, and gaming sectors. Over the last 30 days, Sei averaged a block time (average amount of time it takes for a new block to be added to a blockchain) of 0.41 seconds and a time to finality (duration of time it takes for a transaction to be considered final in a blockchain network) of 0.38 seconds.
Figure 7: Sei stands out for being one of the fastest chains in the current market
Source: Chainspect
In the first version, Sei supported (and still supports in V2) CosmWasm smart contracts, which are Cosmos-based programs that enable DeFi products to be built and be interoperable with other IBC chains. However, one of the biggest requests coming from developers has been additional flexibility in the execution environments that Sei supports, in particular EVM support. In fact, ~90% of blockchain developers contribute to at least one EVM chain. It is for this reason that Sei pursued its first major upgrade (V2) to become the first fully parallelized EVM, introducing a series of features designed to streamline development on Sei while leveraging significant performance improvements. This upgrade allows developers to build on Sei with minimal effort and using the tools they are already familiar with, but benefiting from better performance.
Including two execution environments had the potential to introduce complexity and issues for users and the ecosystem, which Sei had to prevent. First, avoiding liquidity fragmentation, ensuring that tokens were accessible on both the EVM and CosmWasm sides without requiring “wrapped” assets. Second, DEXes and marketplaces needed the capability to list both CosmWasm and EVM tokens. Third, wallet fragmentation had to be avoided, allowing users to interact with any application on Sei using the same wallet. Fourth, solutions to these challenges should not introduce additional risks to users. Lastly, users should not be required to export their private keys to new wallets.
Sei’s answer to these potential issues has been the introduction of precompiled and pointer contracts. Precompile smart contracts allow native Sei functionality from the EVM side providing a gateway for users and developers to access native Sei functionalities through the EVM RPC interface. On the other hand, pointer contracts allow CosmWasm based clients to interact with pointer contracts to access EVM based tokens and NFTs. Likewise, EVM based clients can interact with CosmWasm based tokens and NFTs on Sei via pointer contracts. Thus, a pointer contract acts like a “translator” for its corresponding contract.
With Sei V2, the chain now includes full EVM bytecode compatibility, allowing developers to deploy existing Solidity smart contracts on Sei without requiring code modifications. This backward compatibility is achieved by importing Geth, the Go implementation of the EVM, into the Sei core binary. EVM transactions are wrapped as Sei transactions for processing, integrating seamlessly with Sei’s native mechanisms. Hence, Sei V2 supports two execution environments at once: CosmWasm and the EVM. This means all token standards available on Ethereum blockchains also exist on Sei (e.g., ERC-20 and ERC-721) benefiting from Sei’s optimized performance.
Regarding parallelization of transactions, it is worth noting that while Sei V1 required smart contract developers to optionally define the state that smart contracts were using, Sei V2 enables parallelization at the state access level. Hence, it removes the need for developers to define state access themselves at the smart contract level. The chain optimistically runs transactions in parallel and automatically manages conflicts by tracking the parts of storage each transaction touches. This feature allows the blockchain to handle transactions more efficiently and reduce the developer’s overhead by managing state dependencies internally and resolving conflicts as needed.
Sei consists of various software components supporting the blockchain, including those tied to the consensus and execution layers. Sei V2 will update the execution layer to enable optimistic parallelization and optimized state storage. Additionally, it will introduce a new component for EVM smart contracts, which will benefit from these improvements and interact with existing Cosmwasm smart contracts.
Figure 8: Sei V2 – The Parallel Stack
Source: Sei Blog
The Sei V2 upgrade to a fully parallelized EVM brings with it the following main functionalities aimed at simplifying developer integration as much as possible: (1) backwards compatibility of EVM smart contracts, (2) optimistic parallelization, (3) improvements to the storage layer (SeiDB), and (4) interoperability between EVM and any other execution environments.
Backwards compatibility means that every major contract that exists on Ethereum can seamlessly be redeployed on Sei with no code changes required. This implies a strong advantage for developers as they do not need to rewrite their smart contracts to deploy on Sei.
Sei nodes integrate Geth, a Go implementation of the EVM, to handle Ethereum transactions. Subsequent updates, such as state modifications or interactions with non-EVM contracts, are managed through a specialized interface created by Sei for the EVM.
Figure 9: Backwards compatibility
Source: Sei Blog
Additionally, since the RPC interface for Sei is identical to that of EVM, existing Ethereum tooling can be seamlessly reused. For instance, users can switch their RPC connection in Metamask to use Sei, and developers can continue utilizing tools like Foundry, Remix, and Hardhat.
Executing in parallel can improve throughput by utilizing hardware more efficiently as it employs simultaneous computation of multiple tasks on two or more processing units. Two primary bottlenecks in blockchains are cryptographic functions (hash functions, signatures, elliptical curves, etc.) and memory/state access. One crucial aspect of designing an efficient parallel system for blockchains lies in the nuances of state access. State access involves a transaction’s ability to read from and write to a blockchain’s state, including storage, smart contracts, and account balances. For a parallelized blockchain to be effective and high-performing, optimizing state access is essential – parallel execution is not enough.
There are two main approaches to optimizing state access for parallelized blockchains: deterministic parallelization and optimistic parallelization. Deterministic parallelization requires code to declare upfront which parts of the blockchain state will be accessed and modified, allowing the system to identify which transactions can be processed in parallel without conflicts. This approach ensures predictability and efficiency, especially when transactions are mostly independent, but it adds complexity and extra overhead for developers. As an alternative, optimistic parallelization processes transactions in parallel without requiring upfront state declarations, assuming no conflicts will arise. If conflicts occur, the system re-runs or reprocesses the conflicting transactions serially (one after the other). This method offers more flexibility for developers and is most efficient when conflicts are rare, as re-execution is required for situations when there are conflicts (i.e. two transactions touching the same pieces of state).
As previously stated, Sei V1 implemented deterministic parallelization. Another example of an L1 using this approach is Solana. This approach allows the CPU to identify all dependencies, enabling it to pre-fetch the necessary memory segments. This results in optimized system execution but requires developers to do additional work upfront. On Solana, all memory dependencies for a program must be specified in the constructed transaction (i.e., Access Lists), allowing the runtime to efficiently schedule and execute multiple transactions in parallel. In summary, deterministic parallelization, which emphasizes declaring state access upfront, offers predictability and efficiency, making it ideal for high-throughput applications. In contrast, an optimistic parallelization approach prioritizes developer flexibility and is well-suited for environments where transaction conflicts are infrequent.
With the V2 upgrade, Sei decided to prioritize developer flexibility and moved from a deterministic to an optimistic parallelization approach, making it easier the developer experience by not requiring dependency mappings to be defined. Optimistic parallelization means the chain optimistically runs all transactions in parallel assuming all of them to be eligible for parallel processing. Whenever dependencies between transactions exist (transactions interacting with the same part of Sei’s state), they will be detected and resolved by being re-processed sequentially.
In other words, all transactions are initially executed optimistically, assuming they are independent and do not affect the same state. If conflicts arise during validation, the process adjusts as follows: (1) transactions affecting different parts of storage are re-executed in parallel, and (2) transactions affecting the same state are re-executed sequentially. This recursive process continues until all conflicts are resolved. Since transactions are ordered within a block, this deterministic approach simplifies the developer workflow while maintaining chain-level parallelization.
Figure 10: Optimistic parallelization
Source: Sei Blog
To achieve significant scalability improvements, EVM parallel processing, or transaction parallel processing in general, must be viewed as more than just an optimization at the blockchain’s execution level. It is crucial to consider how database-level optimization is being implemented to fully realize performance enhancements through parallel processing. Even if transactions are parallelized at the execution layer, achieving strong scalability improvements is challenging without corresponding optimization at the database level. Additionally, increasing transaction processing results in more blockchain state creation, necessitating the need to not only parallelize the runtime but also effectively manage the state.
In particular, the growth of the blockchain state, also known as state bloat, is a common issue across all blockchains. For faster blockchains like Sei, this problem is even more pronounced due to the higher transaction throughput. Key issues arising from state bloat include: (1) increased node operation costs, as nodes must store the entire blockchain state, leading to higher storage requirements and costs, (2) decreased blockchain performance, as the state grows, nodes take more time to process and verify transactions, slowing down the network, and (3) node synchronization challenges, as it becomes increasingly difficult for new nodes to join the network due to the extensive state data they must download and verify.
Sei V1 used a vanilla database structure based on the Immutable Adelson-Velsky and Landis (IAVL) tree, a data structure employed by the Cosmos SDK for state storage. However, this structure proved inefficient for several reasons: (1) it requires storing a significant amount of metadata on each node, (2) maintaining balance within the tree necessitates multiple disk accesses, slowing down memory access, and (3) it often results in storing more data than intended (a.k.a. write amplification or the ratio of storage space used to the amount of “useful” data actually stored).
To address these issues, one of the major upgrades of Sei V2 is SeiDB, which with parallelized execution in mind, changes the way that state access, state commitment, and state storage works. The main update was to break the single IAVL tree in two components to avoid all the storage in a single DB: (1) the State Commitment (SC) layer, and (2) the State Store (SS) layer.
Figure 11: Sei V2 – State storage optimization
Source: Sei Blog
The State Commitment layer manages the active state of the Sei blockchain, which pertains to the information of the most recent block height (e.g., current user balances). This data is stored in a memory-mapped IAVL tree using MemIAVL. This design allows validator nodes to track blockchain state using memory mapping (mmap), enabling state access times on the order of hundreds of nanoseconds instead of hundreds of microseconds. This results in significant improvements to state syncing times and read/write amplification. Since SeiDB commits all transaction states asynchronously, commit latency remains constant regardless of the number of transactions handled in a single block.
Figure 12: MemIAVL is 10~287 times faster for writes and 10 times faster for reads compared to traditional tree structures. This figure only focuses on writes.
Source: Sei Blog
On the other hand, the State Storage layer is designed to store and serve the historical state, which refers to all states recorded on the blockchain. In this case, RPC nodes will benefit from a better performance when serving queries. The three main components of State Storage are: (1) raw key-value storage, (2) flexible DB backend, and (3) asynchronous pruning.
Regarding raw key-value pairs, this data storage structure uses a key as a unique identifier and a value as the associated data. For example, in the context of a blockchain, an account balance or the state of a contract is represented by a key, while the corresponding data (such as the amount of tokens in an account) is the value. While key-value storage structures are common in other blockchains and databases, Sei optimizes this by minimizing metadata storage, thus reducing the overall data volume. Additionally, the direct mapping of keys to values without additional abstraction layers enables faster data access, enhancing the overall efficiency of the blockchain.
SeiDB recognizes that node operators have diverse requirements and storage needs. To accommodate this, the State Storage (SS) layer is designed to support various backends, offering operators flexibility and choice. Sei V2 supports multiple databases, including PebbleDB, RocksDB, and SQLite, allowing nodes to select the database that best fits their specific needs.
Figure 13: SeiDB – Comparisons of backends supported
Source: Four Pillars
The final component is asynchronous pruning, which removes unnecessary or outdated data from the blockchain. Unlike traditional methods that impact network performance, Sei performs pruning in the background, optimizing historical state data without affecting primary operations.
To understand the performance improvements between the database used in Sei V1 and the new SeiDB, the following comparison highlights significant enhancements across all key metrics.
Figure 14: SeiDB – Comparison vs Sei V1
Source: Sei Blog
Altogether, SeiDB: (1) improves state read/write performance leading to increased state sync times and decreased commit times for faster time to finality, (2) decreases state bloat with less metadata needing to be stored, and (3) reduces hardware requirements for node operators.
EVM and CosmWasm-based smart contracts coexist on Sei but operate in different execution environments, posing challenges for users and developers. Users often have wallets supporting only one environment, and existing tools and libraries typically interact with either EVM or Wasm (e.g., EthersJS vs. CosmJS). To bridge this gap, Sei V2 introduces two interoperability features, enabling seamless interaction between both environments and making all contracts accessible from both VMs: (1) Precompiled EVM contracts and (2) Pointer Contracts.
When transactions are received, the chain treats them as native Sei transactions and directs them to the appropriate storage sections (e.g., CosmWasm transactions to the Wasm module for execution). This integration ensures a smooth developer experience, allowing EVM developers to easily leverage native tokens and other chain functionalities like staking.
Figure 15: Sei V2 – Interoperability between different execution environments
Source: Sei Blog
Pointer contracts enable interaction between EVM and CosmWasm contracts on Sei. These contracts can be deployed on both the EVM and CosmWasm sides, acting as proxies that relay messages between the two VMs. Through pointer contracts, each token on Sei, whether an NFT (CW-721) or a standard token (CW-20), achieves compatibility with EVM wallets and applications. These contracts link tokens across both environments, enabling seamless usage without the need for “wrapped” assets, ensuring the same token balance is controlled on both EVM and CosmWasm simultaneously.
Figure 16: Sei V2 – Pointer contracts
Source: Sei Documentation
However, pointer contracts do not facilitate interaction with existing Sei apps using an EVM wallet; this requires a feature called precompile contracts. Precompile contracts act as a gateway for users and developers to access native Sei functionalities through the EVM RPC interface, allowing interaction with smart contracts using their preferred wallet. Once funds are deposited into a user’s EVM address, they can be utilized seamlessly with their Sei address, and vice versa. This integration merges them into a single account, ensuring smooth interaction between the EVM and Sei ecosystems.
It is worth highlighting that a common misconception about Sei V2 is that it solely focuses on parallelizing the execution environment, in other words, just enabling multiple transactions to be executed simultaneously, rather than sequentially. However, this view is inaccurate as illustrated in the previous section. In fact, Sei V2 addresses improvements across the entire stack, including state access, state commitment, and state storage.
The V2 upgrade optimizes how transactions read and write data, ensuring faster and more efficient state access, thus maintaining high performance and scalability as transaction volume increases. The state commitment upgrade enables state access times on the order of hundreds of nanoseconds instead of hundreds of microseconds. Lastly, the optimizations in state storage reduce the amount of data stored and improve retrieval times. These improvements help manage the blockchain’s growth more effectively, addressing issues related to state bloat.
In summary, by implementing parallelization, Sei V2 not only improves the execution layer but also integrates these improvements with state access, commitment, and storage, ensuring a complete upgrade to the blockchain’s performance and scalability.
The blockchain ecosystem is evolving with a focus on overcoming the limitations of traditional sequential transaction processing. Sequential chains, while foundational to many early networks, face significant limitations that hinder their scalability, efficiency, and overall performance. The primary downside of sequential chains is their inherent bottleneck in transaction processing, where each transaction must be validated and executed one at a time in a linear sequence. This results in a limited throughput, as the network can only process as many TPS as the slowest node in the chain allows.
During periods of high demand, this bottleneck becomes more pronounced, leading to increased transaction latency and slower confirmation times. Additionally, the sequential nature of these chains exacerbates congestion, causing backlogs that delay transactions further and often result in higher transaction fees as users compete to prioritize their transactions through fee bidding wars.
This not only makes the network less efficient but also less accessible, particularly for small transactions or users who cannot afford high fees. Furthermore, the need for each node to process every transaction sequentially increases the computational load and energy consumption, making the network less sustainable. These limitations collectively prevent the ability of sequential chains to scale effectively, restrict their capacity to support high-frequency and complex applications, and ultimately reduce the user experience and operational efficiency of the chain.
On the other hand, parallel computation enables many calculations or processes to be executed simultaneously. Hence, parallel systems have a number of advantages, such as increased efficiency and speed, scalability, improved reliability and fault tolerance, better resource utilization, and the ability to handle very large data sets. This allows it to support many more users and far more interactive experiences and use cases than existing blockchains, while offering far cheaper per-transaction costs.
Figure 17: Sequential processing vs Parallelization of transactions
Source: Sei Blog
Another important aspect to consider in parallelized processing projects is the chosen execution environment. The EVM is a standout due to its mature developer tools and extensive user base, demonstrated by Solidity’s dominance with a TVL of ~$146B (92.5%) among 17 smart contract languages. This makes EVM compatibility a priority for most projects. Sei recognized the demand for flexible execution environments, especially EVM support. Consequently, with its V2 upgrade, it became the first fully parallelized EVM, seamlessly supporting both CosmWasm and EVM environments.
Figure 18: Solidity dominates among smart contract languages
Source: DefiLlama
An important design aspect of parallel blockchains is choosing between deterministic and optimistic parallelization. Deterministic parallelization, like Solana’s, requires upfront declarations of state access, offering predictability and efficiency but adding complexity for developers. On the other hand, optimistic parallelization, used by Sei and Monad, processes transactions in parallel without upfront state declarations, providing more flexibility for developers. Moreover, despite many projects working on parallelized chains, most are not yet live, including Monad, MegaETH, and Rise. In contrast, Sei is already operational, giving it a competitive first-mover advantage.
Finally, another key design choice that proved advantageous for Sei was opting to be a L1 blockchain instead of a L2. Since its mainnet beta launch in August 2023, Sei has consistently finalized blocks in 390ms and maintained over 45 TPS. This demonstrates that an integrated blockchain can deliver superior performance compared to modular chains. Additional benefits of being an L1 include independence, sovereignty, the ability to fork without reliance on another L1, full ownership and control over the tech stack, and value accrual to its own token.
Numerous parallel processing chains have been introduced to address the bottlenecks of traditional sequential chains, attracting significant VC funding and becoming a key industry narrative. Examples include Monad, which raised $225M, and MegaETH, which recently secured a $20M seed round. The table below compares various parallelized EVMs based on performance metrics and infrastructure, highlighting those already live. As of now, the only live projects on mainnet are Sei V2 and Neon EVM.
Figure 19: Parallelized EVMs competitive landscape
Source: Revelo Intel
The shift from sequential to parallel transaction processing represents a significant advancement in blockchain technology. Parallelized blockchains like Sei V2 can process multiple transactions concurrently, unlike traditional sequential chains that handle one transaction at a time. This leads to drastically improved network performance, scalability, and user experience, allowing the system to handle higher loads and demands. The result is a more efficient and faster network that can support a wider range of applications and transactions without the typical bottlenecks associated with sequential processing.
The Sei V2 upgrade introduces notable changes, such as full EVM compatibility and optimistic parallelization. These enhancements make Sei V2 the first high-performance parallelized EVM chain, enabling developers to leverage existing EVM tools and network effects while benefiting from significant performance improvements. EVM compatibility is crucial as it allows developers to port their applications seamlessly, utilizing familiar tools and avoiding the steep learning curve associated with new ecosystems. This accessibility ensures a broader adoption and integration of high-performance decentralized applications on the Sei network.
In the competitive landscape, Sei V2 stands out due to its robust track record (live on mainnet beta since August 2023), existing developer base, and liquidity from V1. The ability to attract more developers to port their applications, combined with the first-mover advantage in growing an ecosystem, gives Sei a significant edge over competitors. Additionally, Sei’s focus on high-frequency applications, supported by features like Twin-Turbo consensus and native price oracles, positions it well against other high-performance chains such as Solana. The community’s strong backing and strategic partnerships further enhance its competitive position.
Building a parallelized EVM as a L1 blockchain offers numerous benefits. L1 blockchains like Sei have sovereignty and full-stack ownership, allowing them to innovate and optimize without external dependencies. This autonomy ensures faster development cycles and more robust security. Additionally, L1 solutions can achieve superior performance metrics compared to L2 solutions, as demonstrated by Sei’s ability to maintain low latency and high throughput. This architecture not only provides a scalable and high-performance platform but also ensures value accrual to its native token, enhancing the overall ecosystem’s sustainability and growth potential.
DAIC Capital, (2024) Sei: Revolutionizing DeFi with Parallel Execution | Link
Electric Capital, (2023) 2023 Developer Report | Link
Ho D., (2023) Technical Deep Dive on Parallel Execution. Binance Research | Link
Krasnicki P., (2024) Understanding Sei: A Comprehensive Overview. Messari | Link
MacroMark.eth, (2023) Sei Twin-Turbo, A Consensus Engine Review. 3V Labs | Link
phillip_xyz, (2024) Sei V2 key enhancements. X | Link
Revelo Intel, (2024) Monad Industry Intel | Link
Sei, (2023) Sei v2 – The first parallelized EVM blockchain. Sei Blog | Link
Sei, (2023) The Sei Litepaper. Sei Blog | Link
Sei, (2024) SeiDB Deep Dive. Sei Blog | Link
Sei, (2024) Sei v2: EVM and Wasm interoperability. Sei Blog | Link
Sei, (2024) Sei’s Parallel Stack. Sei Blog | Link
Sei Documentation | Link
Sei Ecosystem | Link
Sei Explorer | Link
Sei Network Fundraising. Coincarp | Link
Sei Website | Link
Sheikh A., (2024) Part I: Design Space for Parallel Blockchains. Reciprocal Ventures | Link
Steve, (2024) Sei DB: Why Database Optimization is Crucial for Blockchain Scalability. Four Pillars | Link
Revelo Intel is not engaged in a commercial relationship with Sei and this report was not paid for or commissioned in any way. Members of the Revelo Intel team, including those directly involved in the analysis above, may have positions in $SEI or any other protocols discussed in this report.
This content is provided for educational purposes only and does not constitute financial or investment advice. You should do your own research and only invest what you can afford to lose. Revelo Intel is a research platform and not an investment or financial advisor.
