Key Highlights
- EthSystems has released rotortree, an open-source Merkle tree library for privacy-focused applications.
- The group says rotortree rebuilt 90,435 Tornado Cash commitments in 19 milliseconds.
- EthSystems says a synthetic workload of 748 million commitments was written durably to disk in about 82 seconds.
EthSystems has released rotortree, an open-source Merkle tree library designed to handle large commitment datasets used by shielded transaction systems on Ethereum.
EthSystems introduced the project on August 31 as the first release in its technical series, “Building Blocks.” Its benchmarks focus on how quickly large numbers of transaction commitments can be added to a durable Merkle tree.
EthSystems said the results show a substantial performance improvement over a TypeScript-based library used in its comparison. The figures, however, come from the group’s own testing and have not been independently verified.
Why Merkle Tree performance matters
Privacy-focused transaction systems use Merkle trees to record commitments without publicly exposing the underlying transaction details.
In a shielded pool, each deposit is represented by a cryptographic commitment, often referred to as a note. Those commitments are inserted into the tree, while zero-knowledge proofs can later demonstrate that a particular note exists without revealing the transaction’s full details.
EthSystems said repeated work on shielded systems exposed performance limitations in existing Merkle tree implementations.
The group said those observations led it to develop rotortree as an alternative implementation. Ethereum’s core protocol is moving in a similar direction; developers are separately considering changes like Frame Transactions that would let privacy pools pay their own transaction fees, as part of the proposed 2027 Hegotá upgrade.
Rotortree rebuilds Tornado Cash data in 19 milliseconds
EthSystems first tested rotortree against the historical deposit commitments of Tornado Cash’s largest 1 ETH pool.
The pool contains 90,435 commitments, which rotortree rebuilt in approximately 19 milliseconds. For comparison, the TypeScript implementation used in the benchmark took about 8.58 seconds, resulting in a reported performance difference of roughly 450 times.
Source: Building Blocks Project
EthSystems then tested a larger synthetic dataset of 748 million commitments, which the durable configuration processed in approximately 82 seconds.
The benchmarks were conducted by EthSystems under specific testing conditions and do not represent performance on a live Ethereum privacy application.
Three Design Choices Drive the Reported Performance
EthSystems attributed the benchmark results to three design choices.
- Parallel processing: The library allows Merkle tree insertions to be distributed across multiple CPU cores. EthSystems said parallelization produced roughly a 10x improvement on a 14-core machine.
- Wider tree structure: Instead of limiting each node to two children, rotortree allows developers to configure a larger branching factor. This reduces the number of levels in the tree and can shorten the path required for proofs.
- BLAKE3 hashing: EthSystems replaced the Poseidon hash typically used inside zero-knowledge circuits with BLAKE3 for the Merkle tree structure itself. Combined with the wider tree design, the group said this produced an additional performance improvement of roughly 31x over its parallelized baseline.
The project therefore relies on several changes working together rather than a single optimization.
Durability comes with a performance cost
EthSystems also tested the library with full durability enabled.
The system uses a write-ahead log so that the tree can recover after a crash or process restart.
According to the group, enabling durability reduced raw throughput by approximately 30% compared with its non-durable configuration.
EthSystems described the tradeoff as necessary for applications where the stored commitment tree must survive interruptions rather than exist only in memory.
Rotortree does not solve long-term storage growth
The library is focused on Merkle tree performance, but EthSystems said it does not address the separate problem of storage growth in long-running privacy pools.
As additional commitments are added, the underlying tree continues to grow.
“This crate does not address the issue that limits a long-lived pool, which is that storage grows forever.”
EthSystems said one approach is to create a new tree for each generation, a model already used by some hardened shielded pool designs.
This means faster tree construction does not by itself remove the storage constraints associated with maintaining large privacy systems over long periods.
Security audit has not yet been completed
EthSystems also noted that rotortree has not undergone a formal security audit.
The group said it has conducted differential testing against the existing zk-kit implementation, along with property-based tests and recovery testing designed to examine behavior following interrupted writes.
Those tests provide some evidence about implementation behavior, but they do not replace an independent security audit.
That distinction is particularly relevant for privacy infrastructure, where errors in cryptographic data structures can potentially affect the integrity of transaction systems built on top of them.
Library released as open source
rotortree is available through crates.io and EthSystems’ public repository under the MIT/Apache-2.0 licensing model, according to the group.
EthSystems said rotortree is the first project in its planned “Building Blocks” series, which will focus on technical components used by confidential Ethereum applications.
The group’s next releases are expected to examine additional infrastructure for privacy-focused systems.
For now, rotortree’s significance rests primarily on its reported benchmark results and its approach to scaling Merkle tree construction. Whether those results translate into production performance will depend on independent testing, security review, and adoption by privacy-focused application developers.
Also Read: Robinhood Chain Surpasses Ethereum, Solana in 24 Hours Fees and Revenue
