pith. sign in

arxiv: 2606.17111 · v1 · pith:POEDFRWHnew · submitted 2026-06-15 · 💻 cs.CR · cs.DC· cs.PF

Fractional Verkle Trees: A Hypertree Decomposition and Verified Proof Serialization Architecture for High-Performance Blockchain State Accumulators

Ekleen Kaur , Everton Fraga This is my paper

Pith reviewed 2026-06-27 03:50 UTC · model grok-4.3

classification 💻 cs.CR cs.DCcs.PF
keywords Fractional Verkle Treeshypertree decompositionblockchain state accumulatorsparallel commitment computationVerkle treesMerkle commitment treestateless clientsEthereum state management
0
0 comments X

The pith

Fractional Verkle Trees partition blockchain state into N sub-accumulators to enable lock-free parallel commitments and 91-microsecond root updates.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper identifies four concrete inefficiencies in existing Verkle tree code for Ethereum state management. It introduces Fractional Verkle Trees as a hypertree structure that splits the global accumulator into N independent sub-accumulators whose roots are bound by an outer Merkle tree. This decomposition directly yields improved cache locality, goroutine-parallel commitment without locks, and root recomputation in 91 microseconds instead of roughly 500 milliseconds. The same changes also cut annual network traffic by 4.85 PB across 6,000 full nodes while reducing heap allocations by 57 percent in benchmarks.

Core claim

Fractional Verkle Trees achieve improved cache locality, zero-lock-contention goroutine-parallel commitment computation, and faster root recomputation (91 μs vs ∼500 ms) while eliminating 4.85 PB/year of network traffic across 6,000 full nodes by partitioning global state into N independent sub-accumulators coordinated by a Merkle commitment tree, together with targeted fixes for phantom nodes, 64-byte keys, redundant copies, and non-deterministic serialization.

What carries the argument

The hypertree decomposition that partitions global state into N independent sub-accumulators coordinated by a Merkle commitment tree.

If this is right

  • Root recomputation drops from ~500 ms to 91 μs, making frequent state updates practical on home validators.
  • Commitment computation runs in parallel across goroutines with no lock contention.
  • Network traffic for proof exchange falls by 4.85 PB per year across 6,000 nodes.
  • Heap allocations per 10K proofs fall 57 percent through zero-copy buffers and 32-byte references.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same decomposition pattern could be applied to other polynomial-commitment accumulators that currently suffer from global lock or cache pressure.
  • If the outer Merkle coordination layer adds negligible overhead, similar fractional designs might reduce synchronization costs in any large-scale key-value store that uses tree accumulators.
  • The 32-byte SHA256 node references and HashMap deduplication may generalize to other LSM-based databases that suffer from long keys and compaction overhead.

Load-bearing premise

Splitting the single Verkle accumulator into multiple sub-accumulators whose roots are combined by a Merkle tree preserves the original cryptographic binding and security properties.

What would settle it

An attack that produces a valid-looking overall root commitment without correctly updating or knowing the contents of every sub-accumulator.

read the original abstract

Modern blockchain state management faces a critical scalability bottleneck: maintaining cryptographic commitments over hundreds of millions of entries becomes computationally prohibitive. Ethereum's transition to Verkle Trees: polynomial commitment accumulators reducing proof sizes from O(width * depth) to O(depth) via constant-size IPA vector commitments, is a critical step toward stateless operation. Yet, current implementations exhibit pathological characteristics that burden home validators. We identify four inefficiencies in the reference go-verkle implementation \cite{kaur2025goverkle, kaur2025goethereum}: (1) phantom node creation during non-existent account deletion; (2) 64-byte database keys triggering excessive LSM-tree compaction; (3) redundant memory copying in proof deserialization; (4) a Proof of Absence wire format incompatibility causing non-deterministic serialization. We present Fractional Verkle Trees (FVT), a hypertree decomposition partitioning global state into N independent sub-accumulators coordinated by a Merkle commitment tree, achieving improved cache locality, zero-lock-contention goroutine-parallel commitment computation, and faster root recomputation (91 $\mu$s vs $\sim$500 ms). We address each inefficiency via existence checks, 32-byte SHA256 node references, zero-copy reference-counted buffers, and HashMap-based lexicographic deduplication. Benchmarks on Apple M1 Pro show 57\% heap allocation reduction (566,760 to 242,004 bytes per 10K proofs), parallel insertion at 2,433 ns/op, and network-wide elimination of 4.85 PB/year across 6,000 full nodes, advancing the Ethereum stateless roadmap.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The manuscript proposes Fractional Verkle Trees (FVT), a hypertree decomposition that partitions global blockchain state into N independent Verkle sub-accumulators coordinated by an outer Merkle commitment tree. It identifies four specific inefficiencies in the reference go-verkle implementation (phantom nodes, 64-byte keys, redundant copying, non-deterministic serialization) and claims to resolve them via existence checks, 32-byte SHA256 references, zero-copy buffers, and HashMap deduplication, yielding improved cache locality, lock-free parallel commitment, 57% heap allocation reduction, 91 μs root recomputation (vs. ~500 ms), 2,433 ns/op parallel insertion, and elimination of 4.85 PB/year network traffic across 6,000 nodes.

Significance. If the soundness properties hold, the reported performance gains and traffic reduction would represent a meaningful engineering advance for Ethereum stateless clients by enabling more efficient state accumulation and validator operation on commodity hardware.

major comments (2)
  1. [§3] §3 (Hypertree Construction): No explicit security reduction is supplied showing that an adversary able to produce two distinct openings for an FVT root must break either an inner IPA commitment or the outer Merkle tree. The claim that FVT preserves the binding and uniqueness properties of a monolithic Verkle tree (and thereby advances the stateless roadmap) therefore rests on an unproven architectural assumption.
  2. [§5] §5 (Benchmarks): The concrete performance numbers (91 μs root recomputation, 2,433 ns/op insertion, 566,760 → 242,004 byte heap reduction) are presented without workload definitions, repetition counts, variance measures, or a precise description of the baseline go-verkle version and test harness, preventing independent verification of the claimed speedups and traffic savings.
minor comments (2)
  1. [Abstract] Abstract and §2: The four listed inefficiencies are described at a high level; a short code-path reference or pseudocode snippet for each would clarify the exact defects being addressed.
  2. Notation: The parameter N (number of sub-accumulators) is introduced without discussion of how its value is chosen or its effect on proof size and verification cost.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive comments. We address each major point below.

read point-by-point responses

  1. Referee: [§3] §3 (Hypertree Construction): No explicit security reduction is supplied showing that an adversary able to produce two distinct openings for an FVT root must break either an inner IPA commitment or the outer Merkle tree. The claim that FVT preserves the binding and uniqueness properties of a monolithic Verkle tree (and thereby advances the stateless roadmap) therefore rests on an unproven architectural assumption.

    Authors: We agree the manuscript supplies no explicit security reduction. The FVT construction composes N independent Verkle sub-accumulators under an outer Merkle tree, so binding follows from the binding of the inner IPA commitments together with collision resistance of the Merkle tree; however, we will add a short reduction argument to the revised §3 that formally states an adversary producing two distinct FVT openings must break either an inner IPA or the outer Merkle tree. revision: yes

  2. Referee: [§5] §5 (Benchmarks): The concrete performance numbers (91 μs root recomputation, 2,433 ns/op insertion, 566,760 → 242,004 byte heap reduction) are presented without workload definitions, repetition counts, variance measures, or a precise description of the baseline go-verkle version and test harness, preventing independent verification of the claimed speedups and traffic savings.

    Authors: We accept that the current benchmark description is insufficient for reproducibility. The revised §5 will specify the exact workloads (account counts and operation sequences), repetition counts, variance statistics, the precise go-verkle commit hash used as baseline, and the full test harness (Go version, compiler flags, and hardware). revision: yes

Circularity Check

0 steps flagged

No circularity: architectural proposal with external benchmarks

full rationale

The paper presents an architectural hypertree decomposition (FVT) and reports concrete benchmark measurements (e.g., 91 μs root recomputation, 57% heap reduction, 2,433 ns/op insertion) on Apple M1 Pro hardware. No equations, fitted parameters, or self-definitional derivations appear. Self-citations to prior go-verkle work identify baseline inefficiencies but do not bear the load of the central performance or security claims, which are supported by direct measurements rather than reducing to the citations by construction. The construction is self-contained against external benchmarks.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

The central claim rests on an unstated assumption that the proposed partitioning preserves security; no free parameters, axioms, or invented entities are explicitly quantified in the abstract.

pith-pipeline@v0.9.1-grok · 5835 in / 1153 out tokens · 45982 ms · 2026-06-27T03:50:18.100484+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

40 extracted references · 11 canonical work pages

  1. [1]

    SoK: Sharding in Blockchains

    2019. SoK: Sharding in Blockchains. https://eprint.iacr.org/2019/1286.pdf

    2019

  2. [2]

    Zerializer: Towards Zero-Copy Serialization

    2021. Zerializer: Towards Zero-Copy Serialization. In HotOS 2021. https://dl.acm. org/doi/10.1145/3465480.3467844

    work page doi:10.1145/3465480.3467844 2021

  3. [3]

    EIP-4762: Statelessness Gas Cost Changes

    2022. EIP-4762: Statelessness Gas Cost Changes. https://eips.ethereum.org/EIPS/ eip-4762

    2022

  4. [4]

    EIP-6800: Ethereum State Using a Unified Verkle Tree

    2023. EIP-6800: Ethereum State Using a Unified Verkle Tree. https://eips. ethereum.org/EIPS/eip-6800

    2023

  5. [5]

    Companion of the 2024 International Conference on Management of Data,

    2024. D2Comp: Efficient Offload of LSM-tree Compaction with Data author = Pa- van Edara and Jonathan Forbesj and Bigang Li Processing Units on Disaggregated Storage. In ACM SIGMOD 2024. https://dl.acm.org/doi/10.1145/3626246.3653396

    work page doi:10.1145/3626246.3653396 2024

  6. [6]

    SoK: Public Blockchain Sharding

    2024. SoK: Public Blockchain Sharding. https://eprint.iacr.org/2024/025.pdf

    2024

  7. [7]

    Josh Benaloh and Michael de Mare. 1994. One-Way Accumulators: A Decen- tralized Alternative to Digital Signatures. In EUROCRYPT 1993 (LNCS, Vol. 765) . Springer, 274–285. https://link.springer.com/chapter/10.1007/3-540-48285-7_24

    work page doi:10.1007/3-540-48285-7_24 1994

  8. [8]

    Dan Boneh, Benedikt Bünz, and Ben Fisch. 2019. Batching Techniques for Accu- mulators with Applications to IOPs and Stateless Blockchains. In CRYPTO 2019 (LNCS, Vol. 11692). Springer, 561–586. https://eprint.iacr.org/2018/1188.pdf

    2019

  9. [9]

    Joseph Bonneau, Jovan Chen, Matthew Christ, and Ioanna Karantaidou. 2025. Merkle Mountain Ranges Are Optimal: On Witness Update Frequency for Cryp- tographic Accumulators. https://eprint.iacr.org/2025/234.pdf

    2025

  10. [10]

    Bronson, Jared Casper, Hassan Chafi, and Kunle Olukotun

    Nathan G. Bronson, Jared Casper, Hassan Chafi, and Kunle Olukotun. 2010. A Practical Concurrent Binary Search Tree. In PPoPP 2010. ACM, 257–268. https: //dl.acm.org/doi/10.1145/1693453.1693488

    work page doi:10.1145/1693453.1693488 2010

  11. [11]

    Benedikt Bünz, Jonathan Bootle, Dan Boneh, Andrew Poelstra, Pieter Wuille, and Greg Maxwell. 2018. Bulletproofs: Short Proofs for Confidential Transactions and More. In IEEE S&P 2018. 315–334. https://eprint.iacr.org/2017/1066.pdf

    2018

  12. [12]

    Vitalik Buterin. 2021. Verkle Trees. https://vitalik.eth.limo/general/2021/06/18/ verkle.html

    2021

  13. [13]

    Jan Camenisch and Anna Lysyanskaya. 2002. Dynamic Accumulators and Ap- plication to Efficient Revocation of Anonymous Credentials. In CRYPTO 2002 (LNCS, Vol. 2442). Springer, 61–76. https://link.springer.com/chapter/10.1007/3- 540-45708-9_5

    work page doi:10.1007/3- 2002

  14. [14]

    Dario Catalano and Dario Fiore. 2013. Vector Commitments and Their Appli- cations. In PKC 2013 (LNCS, Vol. 7778). Springer, 55–72. https://eprint.iacr.org/ 2011/495.pdf

    2013

  15. [15]

    Faith Ellen, Panagiota Fatourou, Eric Ruppert, and Franck van Breugel. 2010. Non-blocking Binary Search Trees. In PODC 2010. ACM, 131–140. https://dl.acm. org/doi/10.1145/1835698.1835736

    work page doi:10.1145/1835698.1835736 2010

  16. [16]

    Ethereum Foundation. 2019. The 1.x Files: The State of Stateless Ethereum. https://blog.ethereum.org/2019/12/30/eth1x-files-state-of-stateless-ethereum

    2019

  17. [17]

    Ethereum Foundation. 2021. Dodging a Bullet: Ethereum State Problems. https: //blog.ethereum.org/2021/05/18/eth-state-problems

    2021

  18. [18]

    Ethereum Foundation. 2024. go-ethereum: Official Go Implementation of the Ethereum Protocol. https://github.com/ethereum/go-ethereum. Accessed: April 2026

    2024

  19. [19]

    Ethereum Foundation. 2024. go-verkle: Go Implementation of Verkle Trees for Ethereum. https://github.com/ethereum/go-verkle. Accessed: April 2026

    2024

  20. [20]

    Dankrad Feist. 2021. Verkle Trie for Eth1 State. https://dankradfeist.de/ethereum/ 2021/06/18/verkle-trie-for-eth1.html

    2021

  21. [21]

    Maksim Iavich, Tamari Kuchukhidze, and Razvan Bocu. 2025. Fractional Verkle Trees for Scalable Post-Quantum Signatures. IEEE Access 13 (2025), 209921– 209937. https://doi.org/10.1109/ACCESS.2025.3640288

    work page doi:10.1109/access.2025.3640288 2025

  22. [22]

    Zaverucha, and Ian Goldberg

    Aniket Kate, Gregory M. Zaverucha, and Ian Goldberg. 2010. CPolynomial Commitments. In ASIACRYPT 2010 (LNCS, Vol. 6477) . Springer, 177–194. https: //cacr.uwaterloo.ca/techreports/2010/cacr2010-10.pdf

    2010

  23. [23]

    Ekleen Kaur. 2021. Time Transitive Functions for Zero Knowledge Proofs. arXiv:2108.06389 [cs.CR]

    arXiv 2021

  24. [24]

    Ekleen Kaur. 2022. IoT Regulated Water Quality Prediction Through Machine Learning for Smart Environments. In Proceedings. https://doi.org/10.1007/978-3- 030-97516-6_3

    work page doi:10.1007/978-3- 2022

  25. [25]

    Ekleen Kaur. 2025. Go-Ethereum: Modified Ethereum Client with Verkle Tree Optimizations. https://github.com/eclairss17/Go-Ethereum

    2025

  26. [26]

    Ekleen Kaur. 2025. Go-Verkle: Fractional Verkle Tree Implementation in Go. https://github.com/eclairss17/Go-Verkle

    2025

  27. [27]

    Ekleen Kaur. 2025. The Limits of Conditional Volatility: Assessing Cryptocurrency VaR under EWMA and IGARCH Models. arXiv:2601.13757

    arXiv 2025

  28. [28]

    Ekleen Kaur. 2025. The Limits of Lognormal: Assessing Cryptocurrency Volatility and VaR using Geometric Brownian Motion. arXiv:2601.14272 12 Fractional Verkle Trees: A Hypertree Decomposition and Verified Proof Serialization Architecture for High-Performance Blockchain State Accumulators. , ,

    arXiv 2025

  29. [29]

    Ekleen Kaur and A. Oza. 2020. Blockchain-based multi-organization taxonomy for smart cities. SN Applied Sciences 2 (2020), 440. https://doi.org/10.1007/s42452- 020-2187-4

    work page doi:10.1007/s42452- 2020

  30. [30]

    Kolokasis, Giannos Evdorou, Anastasios Papagiannis, Foivos Zakkak, Christos Kozanitis, Shoaib Akram, Polyvios Pratikakis, and Angelos Bilas

    Iacovos G. Kolokasis, Giannos Evdorou, Anastasios Papagiannis, Foivos Zakkak, Christos Kozanitis, Shoaib Akram, Polyvios Pratikakis, and Angelos Bilas. 2023. Garbage Collection or Serialization? Between a Rock and a Hard Place!. InASPLOS

    2023

  31. [31]

    https://dl.acm.org/doi/10.1145/3582016.3582021

    work page doi:10.1145/3582016.3582021

  32. [32]

    John Kuszmaul. 2018. Verkle Trees. https://math.mit.edu/research/highschool/ primes/materials/2018/Kuszmaul.pdf

    2018

  33. [33]

    Chen Luo and Michael J. Carey. 2020. LSM-based Storage Techniques: A Survey. VLDB Journal 29 (2020), 393–418. https://link.springer.com/article/10.1007/ s00778-019-00555-y

    2020

  34. [34]

    Simon Masson, Antonio Sanso, and Zhenfei Zhang. 2021. Bandersnatch: A Fast Elliptic Curve Built over the BLS12-381 Scalar Field. https://eprint.iacr.org/2021/ 1152.pdf

    2021

  35. [35]

    Maged M. Michael. 2002. High Performance Dynamic Lock-Free Hash Tables and List-Based Sets. In SPAA 2002. ACM, 73–82. https://dl.acm.org/doi/10.1145/ 564870.564881

    arXiv 2002

  36. [36]

    Satoshi Nakamoto. 2008. Bitcoin: A Peer-to-Peer Electronic Cash System. https: //bitcoin.org/bitcoin.pdf

    2008

  37. [37]

    Ruslan Nikolaev and Binoy Ravindran. 2021. Snapshot-Free, Transparent, and Robust Memory Reclamation for Lock-Free Data Structures. In PLDI 2021. ACM, 987–1002. https://dl.acm.org/doi/10.1145/3453483.3454090

    work page doi:10.1145/3453483.3454090 2021

  38. [38]

    Jan Oberst. 2025. Towards Stateless Clients in Ethereum: Benchmarking Verkle Trees and Binary Merkle Trees with SNARKs. https://arxiv.org/abs/2504.14069

    arXiv 2025

  39. [39]

    Patrick O’Neil, Edward Cheng, Dieter Gawlick, and Elizabeth O’Neil. 1996. The Log-Structured Merge-Tree (LSM-Tree). Acta Informatica 33, 4 (1996), 351–385. https://www.cs.umb.edu/~poneil/lsmtree.pdf

    1996

  40. [40]

    Xiongfei Zhao et al. 2024. Minimizing Block Incentive Volatility Through Verkle Tree-Based Dynamic Transaction Storage. arXiv:2402.04533 [cs.CR] 13

    arXiv 2024