The proposal, called Promethon, is described in a paper published in Frontiers in Blockchain by Seyed Sepehr Mirnasrollahi Parsa, AmirHossein Aghajari, and Salman Niksefat. It operationalizes the concept of state rent, first floated by Vitalik Buterin, which suggested periodically charging accounts for occupying space in Ethereum’s world state. Until now, such ideas remained high-level sketches that did not explain how to implement the charging mechanism efficiently, or how to guarantee that removing expired state would not increase the computational complexity of operating the network. Promethon claims to be the first comprehensive, implementation-ready solution that preserves Ethereum’s current performance guarantees while actively shrinking the world state.

The urgency behind the work is grounded in striking data. The researchers independently analyzed Ethereum blocks from 2024 using the BigQuery API and found that in the first six months of that year, 1,882,687 contracts were created, of which 1,701,693, or 90.38 percent, were never called in the following six months. Over the full year, 3,036,254 contracts were created and never used again, representing 75.33 percent of all deployed contracts. As of 20 July 2025, Ethereum’s world state held more than 328 million accounts, and a new block is produced roughly every 12 seconds. The accumulation of dormant state imposes rising storage, synchronization, and processing costs on every node in the network.

At the heart of Promethon lies a mandatory rental fee. In contrast to the current Ethereum model, where the cost of storing data is incurred only once during the transaction that saves it, Promethon deducts a nominal amount from all accounts per block, proportional to their storage trie usage. If an account’s balance drops to zero due to these deductions, the account is automatically deleted. The challenge is that charging every account at every block would require iterating over the entire dataset, an overhead that is plainly infeasible at Ethereum’s scale. One initial idea, organizing accounts in ascending order in an array and managing only the minimum-balance account, fails because any transaction that alters an account’s position would necessitate a costly rearrangement.

The researchers’ breakthrough is a unified hybrid data structure that merges the ordering properties of a red-black tree directly into the leaf layer of the Merkle-Patricia trie, the cryptographic structure Ethereum already uses to store and verify its world state. Instead of maintaining two separate structures and synchronizing pointers between them, each account’s trie leaf is extended with red-black tree metadata, including a color bit and parent, left, and right pointers that refer to other nodes by account address. The red-black tree keeps accounts sorted by effective balance, so the rent mechanism needs to evaluate only the lowest-balance accounts during each period. Accounts capable of paying remain, while insufficient ones are deleted efficiently, without the overhead of traversing or modifying two independent structures.

The red-black tree is a self-balancing binary search tree whose five properties, such as the rule that no two red nodes can be adjacent and that every path from a node to its descendant leaves must contain the same number of black nodes, guarantee a worst-case time complexity of O(log n) for insertion and deletion. This is achieved through a corrective fix-up procedure, executed immediately after a node is inserted or deleted, which restores balance through recoloring and rotations. Meanwhile, the Merkle-Patricia trie provides Ethereum’s cryptographic guarantees: a single root hash that commits to all account key-value bindings, and Merkle proofs of length proportional to the address length that enable light-client verification. Crucially, because the red-black tree operations are part of the prescribed state-transition function and are executed identically by every validator, all validators converge on the same tree structure, preserving byte-identical leaf hashes, proofs, and the global root hash.

The mechanism operates through two algorithms invoked during block creation. The first, ExecTrans, charges the sender for the rent accrued since the account was last modified, calculated by counting the number of blocks since the last rent payment and multiplying it by the storage fee per block, which is proportional to the account’s storage usage. If the sender’s balance remains sufficient after payment, the transaction proceeds; otherwise, it is reverted. Balances are then updated in the red-black tree, and a fix-up maintains the sorted order. The second algorithm, CheckZero, navigates to the leftmost branch of the red-black tree to identify the account with the minimum effective balance. If that account is solvent, all other accounts are guaranteed to be solvent as well, and the check terminates; otherwise, deletion proceeds from both the trie and the tree, followed by a fix-up. This lazy collection ensures that every byte-block of state usage is charged exactly once, while the per-block work remains modest.

The complexity analysis is where Promethon makes its strongest case. Ethereum currently executes transactions in O(k) time, where k is the account address length, and executes blocks of n transactions in O(n log n). A red-black tree operation also runs in O(log n) steps, and since the number of accounts n is bounded above by 2^160, the maximum number of distinct 20-byte addresses, log n is always less than k. The overall complexity for transaction execution under Promethon is therefore O(k + log n), approximately O(k), matching today’s costs. Account deletion adds only O(d log n) per block, where d is the typically very small number of accounts deleted, and storage complexity remains O(n), consistent with the existing architecture. By comparison, a linear approach that scans all accounts at each block would incur O(n + d·k) overhead, which the authors’ benchmarks on a MacBook Pro with an Apple M3 Pro chip, processing the first one million real Ethereum transactions in batches of 1,000, showed to be dramatically outperformed by their PromethoniXTrie implementation as the dataset grew.

The researchers also confront the economic and adversarial dimensions of the design. The rent formula follows the standard time-space unit-price model used by commercial storage markets and decentralized protocols such as Filecoin. Two distribution models are compatible with the mechanism: collected rent could be credited to block proposers as an aggregate validator reward, or permanently burnt, mirroring the base-fee burning of EIP-1559, which would give validators no economic interest in either expanding or shrinking the state. The threat model shows that spam attacks are self-funded and self-mitigating, targeted deletion of a victim account is structurally impossible because external parties can only extend an account’s life by sending it Ether, and dishonest validators who omit rent or skip deletions produce a divergent state root that fails attestation. The authors do acknowledge a genuine usability limitation: a legitimate user who remains offline long enough could have their account drained by rent, though conservative governance of the per-byte fee and arbitrarily large pre-funded rent buffers can provide multi-year survival windows.

Deploying Promethon on the Ethereum mainnet would require a hard fork, since extending the encoding of trie leaf nodes with red-black tree metadata alters the global state root, and the augmented state-transition function would cause un-upgraded clients to compute different roots for the same block. A one-time migration at the fork block would sort existing accounts by effective balance and build the initial balanced tree layout, an operation clients perform off-chain during the upgrade window. Notably, the design is compatible with Ethereum’s longer-term roadmap: because planned upgrades such as Verkle trees replace the commitment layer while leaves remain key-value bindings, the red-black metadata can be embedded inside Verkle leaf values exactly as it is inside Merkle-Patricia leaves, allowing Promethon to be deployed before, after, or alongside the Verkle transition. The pilot implementation in Go, the same language as Geth, the most widely deployed Ethereum client, is publicly available on GitHub. Whether the Ethereum community embraces recurring storage fees or continues to weigh alternatives such as time-based state expiry, Promethon demonstrates that the world state problem now has an answer measured not in concepts but in algorithms, code, and benchmarks.

Subject of Research: Promethon: efficient reduction of Ethereum’s world state size using red-black trees

Article Title: Promethon: efficient reduction of Ethereum’s world state size using red-black trees

Article References: Mirnasrollahi Parsa, S. S., Aghajari, A., & Niksefat, S. (2026). Promethon: efficient reduction of Ethereum’s world state size using red-black trees. Frontiers in Blockchain, 9, Article 1837907. https://doi.org/10.3389/fbloc.2026.1837907

Image Credits: AI Generated

DOI: 10.3389/fbloc.2026.1837907

Keywords: Promethon, efficient, reduction, Ethereum, world, state, size, red-black, trees, scientific research