Abstract
Parallel execution is frequently cited as the primary solution to the blockchain scalability trilemma. By moving away from sequential processing, networks aim to achieve the throughput necessary for global adoption. However, this study reveals that the evolution of the Ethereum ecosystem—specifically the rise of Decentralized Finance (DeFi) and Non-Fungible Tokens (NFTs)—has created a highly interconnected transaction graph that fundamentally limits concurrency. Through an analysis of Ethereum Mainnet data, researchers found that even with optimized scheduling and the removal of artificial dependencies, the potential speedup from parallelization is capped at approximately five times the current throughput.
Introduction
To compete with centralized payment processors like Visa, blockchains must overcome the bottleneck of sequential execution, where each transaction is processed one after another. Parallelization (multithreading) offers a theoretical path forward, allowing independent transactions—such as a simple transfer between two individuals—to be processed simultaneously.
However, the efficacy of parallelization depends entirely on transaction independence. As the Ethereum ecosystem has matured, it has shifted from simple peer-to-peer transfers to complex interactions with shared smart contracts. This paper investigates whether the modern Ethereum workload, dominated by liquidity pools and NFT marketplaces, actually permits the concurrency that many scaling solutions assume.
Methodology
The researchers modeled Ethereum transactions using two distinct graph representations to identify dependencies:
- Address-based Graphs: Vertices represent addresses (wallets or contracts), and edges represent calls between them.
- Transaction-based Graphs: Vertices represent individual transactions. An edge is drawn between two transactions if they interact with the same address, indicating a state dependency that requires sequential handling.
To determine the theoretical limits of speedup, the study focused on Connected Components (groups of linked transactions) and Cliques (groups where every transaction depends on every other transaction). The "heaviest" component, measured by gas consumption, sets the lower bound for execution time, as these transactions cannot be split across threads.
The "Disentanglement" Approach
A significant contribution of this research is the concept of "disentanglement." The authors noted that many dependencies are "artificial." For instance, multiple users interacting with a single ERC-20 token contract appear to conflict because they call the same contract address, even if they are modifying different balance variables. The researchers manually disentangled these interactions for the top five tokens and major decentralized exchange (DEX) routers to simulate the "true" underlying potential for parallelization.
Data and Metrics
The study utilized data from the Ethereum Mainnet via an Erigon client, comprising two datasets:
- Historical Analysis: A longitudinal sample of 65 blocks per day across Ethereum’s history through August 2022.
- Recent Deep-Dive: A comprehensive analysis of every block from June 1, 2022, to August 31, 2022.
The researchers used Gas as a proxy for execution time, as it accurately reflects the computational complexity and storage access requirements of a transaction.
Key Insights
The Impact of "DeFi Summer"
The transition to DeFi-centric usage has fundamentally altered Ethereum's execution profile. Before 2020, transactions were largely independent. Since the rise of DeFi and NFTs, the number of interdependencies per block has more than doubled—increasing from approximately 2,000 to 5,000—despite the total number of transactions per block remaining relatively stable.
The Centralization of State
A small number of "hub" contracts, such as Wrapped Ether (WETH), USDC, and Uniswap routers, act as massive bottlenecks. Most transactions in a modern block now belong to a single, massive connected component. Transactions interacting with WETH, in particular, almost always form the "heaviest clique" in a block, serving as the primary driver of sequential bottlenecks.
The "Heaviest Transaction" Floor
Parallelization is limited not only by dependencies but by the complexity of individual transactions. On average, the single largest transaction in a block accounts for roughly 1/9th of the total gas. Because a single transaction cannot be parallelized across multiple cores, the execution time of a block can never be faster than its slowest individual transaction.
Results and Scalability Limits
The study concludes that the "Scalability Ceiling" is much lower than previously hoped:
- Realistic Speedup: In the original transaction data, the maximum realistic speedup through parallelization is currently limited to 3x.
- Optimistic Ceiling: Even with the "disentangled" model that removes artificial dependencies, the speedup factor rarely exceeds 5x.
- Interconnectivity: Currently, a mere 200 transactions per block generate roughly 4,000 interdependencies, creating a dense web that resists multithreading.
Conclusion and Future Directions
The findings suggest that simply adding more cores to a blockchain validator will not yield linear performance gains. To move beyond the 5x limit, the researchers propose three strategic shifts:
- Smart Contract Redesign: Developers should move away from "hub" designs that force all users through a single bottleneck, opting instead for more distributed state management.
- Economic Incentives: Implementing superlinear gas pricing for complex, "heavy" transactions could discourage the creation of massive sequential bottlenecks that hinder the entire network.
- Predictive Execution: Encouraging the use of access lists (such as EIP-2930) would allow the network to identify parallelizable transactions before execution begins, optimizing the scheduling process.
While parallelization remains a vital tool, this research highlights that the bottleneck is not just in the software architecture, but in the very way users and applications interact with the blockchain's shared state.
Summary updated