The perpetual storage model adopted by early blockchains contains a contradiction that becomes more evident with every adoption cycle. Requiring every validator node to retain the entirety of the state —the set of balances, nonces, and contract storage accessible in the latest block— without any expiration mechanism amounts to imposing an asymptotic burden on operators.
Over time, that burden transforms independent verification into a privilege of infrastructure. State expiry is not a cosmetic optimization: it constitutes the technical answer to how a permissionless protocol can preserve verifiability when usage is measured in decades.
Understanding the magnitude of the problem requires separating two components often conflated. The transaction history is a sequential record that can be pruned, archived, or distributed without affecting the validation of the present.
The state is the up-to-date photograph of everything a transaction can read or modify directly: every account, every storage slot of every contract, every entry in a map. Validating a block demands low-latency random access to arbitrary fragments of the state.
For that reason, the state must reside on SSD drives and, to a significant extent, in the RAM of full nodes. While the history admits cold storage solutions, the state imposes hardware costs that grow monotonically.
The inertial expansion of the state is a direct consequence of data permanence. A new user, a new token, or a new position in a DeFi protocol adds entries that, even when they cease to be used, do not disappear.
Operations that free up space in high-level languages often translate into writes that set a variable to zero, without eliminating the slot from the underlying state tree. Ethereum’s experience is illustrative: the state has grown from a few gigabytes in 2016 to several hundred gigabytes today. That trend increases storage requirements, raises synchronization times, and, above all, reduces the number of actors capable of operating a full validation node.
The concentration of nodes in data centers and cloud providers represents the most damaging consequence. When hardware costs exclude participants with consumer-grade equipment, the “don’t trust, verify” principle degrades into an architecture where most users delegate verification to external infrastructure, often centralized in a handful of RPC providers.
The centralizing pressure induced by the state operates silently, without requiring protocol changes or malicious actors. It suffices that the incremental cost pushes out home validators for the consensus layer to rest upon an increasingly homogeneous set of entities.
Faced with this diagnosis, simply deleting old state is not a viable option. If a node discards the information corresponding to an account that has been inactive for years, it becomes incapable of validating a future transaction involving that account.
Not knowing the balance and nonce prevents determining whether the operation is legitimate or constitutes a double-spend attempt. Recomputing the state from the genesis block to restore a single account is computationally prohibitive. The technical key lies, therefore, in transferring the storage burden from consensus to the user, without sacrificing the verification capacity of validators. That is what state expiry pursues.
State expiry defines a temporal boundary: data not accessed during a pre-established period transitions from the active state that validators must maintain to a secondary storage layer. The active state remains bounded, while the expired state is not destroyed: it remains available in external repositories and can be resurrected when the account holder decides to interact with the network again.
Verkle trees constitute the fundamental enabler of that change. Unlike current Merkle-Patricia trees, vector commitments based on Verkle produce proofs of reduced size —on the order of a few hundred bytes— that allow demonstrating a key’s value and, at the same time, proving that the key has not been modified since the moment of expiration.
When a user wishes to reactivate a dormant account, they attach a witness containing the cryptographic proof of the last valid state. Validators verify the witness without having stored the expired data and, after verification, incorporate the account into the active state. The network does not preserve perpetual state; it preserves the capacity to validate its resurrection on demand.
The work plan described by Ethereum researchers further introduces a modification to the address format to include an epoch marker. This marker allows unambiguous determination of whether an account belongs to an already expired period and which Merkle root should be used to verify the witness.
The epoch-based expiry mechanism segments the state based on last access and provides a clear path for wallet software to manage witnesses automatically. The user does not need to understand the underlying infrastructure; the wallet stores or retrieves the witness when appropriate.
The combination of stateless validation and progressive expiry offers a scaling perspective that decouples validator requirements from the accumulated growth of the network. In a fully stateless scheme, validators would not retain any state and would receive witnesses with every transaction.
State expiry can be understood as a hybrid implementation: validators maintain hot state —that which is modified frequently— and demand witnesses only for data that has exceeded the inactivity threshold.
The result is a bounded active state size that can be set at a value compatible with consumer disks, for example between 20 and 50 GB. With that limit, operating a full validator node remains feasible for anyone with a standard broadband connection and a laptop.
The challenges posed by this model are not trivial and concentrate in three areas: witness availability, user experience, and dependence on inactive contracts. Witness availability requires the existence of archive nodes or state providers that retain the expired data and generate proofs on demand.
If those providers consolidate into a small number of entities, a new centralization vector appears, although of a different nature: it does not affect consensus validation, but it does affect the ability of users to recover their accounts autonomously.
Mitigating that risk demands witness distribution protocols that allow wallets to store their own proof at the moment of expiration or to replicate it across decentralized storage networks.
The user experience is modified because the holder of an account that remains inactive for years must retain or be able to recover the corresponding witness. Wallets will have to incorporate automatic resurrection flows that abstract away that complexity.
A user who receives an asset at a dormant address and is unaware of the witness mechanism might find that the transaction requires an additional reactivation step. The evolution of wallet standards and communication with exchanges are essential so that expiry does not translate into operational friction.
The third challenge concerns low-frequency but systemically relevant smart contracts. A governance contract invoked only during exceptional situations could expire between votes. The resurrection cost —both in gas and in witness provision— must be sufficiently low that reactivation does not introduce economic barriers.
Protocol designers are studying mechanisms that allow contracts themselves to pay for their permanence in the active state or to delegate periodic renewal to third parties through economically rational “keep-alive” transactions.
Previous alternatives to witness-based state expiry, such as state rent, attempted to address expansion through recurring storage payments. That path generated rejection due to the effects on property: the possibility of losing an NFT or a balance for not paying a periodic fee contradicts fundamental user expectations.
Expiry with witnesses inverts the logic: the data is not lost, but its custody is transferred to the interested party. The protocol stops guaranteeing perpetual storage and starts guaranteeing perpetual verifiability. That distinction is central to understanding the paradigm shift.
Implementing state expiry requires modifying the execution layer, updating the global state data structures, and coordinating a transition in the address format. Ethereum’s technical timeline places the migration to Verkle trees as a necessary prior step, followed by the progressive introduction of epoch-based expiry.
The client developer community and research teams are working on prototypes that allow evaluating resurrection costs and the bandwidth overhead associated with including witnesses in transactions. Preliminary results indicate that the increase in block size due to witness inclusion is manageable, especially if proof aggregation schemes are applied.
The relevance of this debate transcends Ethereum. Other layer-one architectures that aspire to maintain full nodes on consumer devices face the same bottleneck. The preservation of validation decentralization demands in all of them an explicit commitment to state bounding. Designs that postpone this discussion while focusing exclusively on throughput increases through parallel execution or external data availability are accumulating technical debt that will manifest when the active state surpasses the hardware capabilities accessible to the independent operator.
State expiry constitutes, ultimately, an architectural decision about who bears the cost of the passage of time in a decentralized network. If that cost is socialized among all validators, the result is constant pressure toward infrastructure centralization.
If, on the contrary, it is assigned to whoever generates the demand for permanence, the system can set an upper bound on the active state and maintain verifiability on low-cost equipment. Witness technology and Verkle trees offer for the first time a path to implement that assignment without sacrificing trustless verification capacity.
A protocol that does not incorporate state expiry can function for years without evident signs of deterioration, but it accumulates a structural fragility that becomes irreversible when home operators abandon the network.
The history of distributed systems shows that the coordination complexity to introduce changes of this caliber grows exponentially with the size of the ecosystem. For that reason, the technical discussion on expiry, witnesses, and Verkle does not represent an academic debate, but a race against the inertia of growth.
Networks that solve this technical equation will retain the capacity to be verified by any participant. Those that do not will become, over time, distributed databases managed by a few, regardless of the decentralization discourse they uphold.
Be the first to comment