Ethereum’s long-term security roadmap faces a challenge that extends beyond protecting private keys. As cryptographic systems evolve, the signatures and proofs used to verify blockchain activity may become substantially larger, placing additional demands on network bandwidth and on-chain data availability. This issue becomes particularly relevant as blockchain developers explore post-quantum cryptography and more advanced zero-knowledge proof systems. On November 16, 2026, Ethereum co-founder Vitalik Buterin expressed strong support for leanPCS, a potential approach associated with EIP-8288. The proposal explores how cryptographic proofs could be aggregated before reaching a block, allowing Ethereum to verify more information without requiring every original proof to be published on-chain.
Cryptography is fundamental to how Ethereum establishes trust. It allows network participants to verify transactions, authenticate messages, validate computations, and confirm that certain conditions have been satisfied without relying on a central authority.
However, cryptographic verification also has a resource cost. Every signature, proof, or piece of verification data that must be processed or made available to the network contributes to the demands placed on Ethereum’s infrastructure. As applications become more sophisticated and cryptographic standards evolve, managing these costs becomes increasingly important.
A digital signature demonstrates that a message or transaction was authorized by the holder of a corresponding private key. On Ethereum, signatures are essential to account authorization and transaction validation. They allow the network to establish that a transaction was properly approved without exposing the private key itself.
Zero-knowledge proofs and other cryptographic proofs serve a different but related purpose. They allow one party to demonstrate that a statement or computation is valid without requiring the verifier to repeat the entire process or access all the underlying information.
For example, a zero-knowledge proof can demonstrate that a transaction satisfies certain conditions without revealing sensitive transaction details. A STARK proof can demonstrate that a particular computation was executed correctly. Merkle branches can establish that a specific piece of data belongs to a larger data structure, such as a set of transactions or account records.
These mechanisms support a broad range of Ethereum use cases, including:
As the ecosystem expands, Ethereum needs ways to handle these cryptographic operations without allowing verification data to become an increasingly significant bottleneck.
The transition toward post-quantum cryptography is one reason this challenge deserves attention.
Many widely used cryptographic systems rely on mathematical problems that are considered difficult for conventional computers to solve. However, sufficiently capable quantum computers could threaten some of these assumptions. In particular, Shor’s algorithm could undermine the security of commonly used public-key cryptographic systems, including elliptic-curve-based signatures.
This does not mean that quantum computers can currently break Ethereum’s cryptography. Rather, the possibility of future advances creates a reason to investigate alternative cryptographic systems before they become urgently necessary.
Post-quantum cryptography includes approaches designed to resist attacks from both classical and quantum computers. Hash-based signatures, lattice-based cryptography, and other candidate techniques are among the areas being explored.
The challenge is that stronger long-term security does not necessarily mean smaller cryptographic data.
For example, Vitalik highlighted the potential difference between conventional ECDSA signatures and hash-based post-quantum signatures. A conventional ECDSA signature is typically 65 bytes in the relevant Ethereum transaction context, while some WOTS or SPHINCS-based alternatives can require approximately 1–6 KB, depending on the construction and parameters.
Proof systems can also become substantially larger. Vitalik compared certain succinct proof formats, which may occupy approximately 200–1,000 bytes, with STARK proofs that can reach around 128 KB in some configurations.
These figures are illustrative comparisons rather than universal sizes for every signature or proof system. Actual data requirements depend on the cryptographic construction, security parameters, and implementation.
Nevertheless, the broader concern is clear: if Ethereum simply requires every larger signature and proof to be transmitted and stored in its original form, the additional data could create substantial costs for network participants.
Ethereum is a distributed network. Its participants must independently process and verify relevant blockchain information according to the protocol’s rules.
When transactions or verification data become larger, the network may face several related challenges:
The objective is not simply to make individual proofs smaller. Ethereum also needs a way to organize verification so that the network does not repeatedly process or distribute information that can be represented more efficiently.
This is the broader problem that EIP-8288 and the associated lean approaches seek to address.
EIP-8288 is associated with an approach to scaling cryptographic verification by aggregating proofs before they are included in a block.
The central idea is to separate the generation and initial verification of cryptographic objects from the information that ultimately needs to be recorded on-chain. Instead of requiring every original signature or proof to be repeatedly transmitted as a separate object, the system could combine multiple verification results into a more compact representation.
Vitalik described the underlying goal as hyper-scaling data and execution for computations that need to be performed on a piece of data once, after which the chain can learn the result without needing to receive the original data again.
This concept is relevant to several types of cryptographic operations, including:
Among these examples, Vitalik emphasized signatures and STARK proofs as particularly important applications.
The proposed process involves aggregating cryptographic proofs within Ethereum’s mempool, the area where pending transactions and related information are collected before inclusion in a block.
The process can be understood in several stages.
1. Users generate cryptographic objects
A user first creates the relevant cryptographic object. Depending on the application, this could be a digital signature, a STARK proof, or a polynomial commitment opening, commonly called a PCS opening.
The user then publishes the object so that network participants can receive it.
2. Nodes collect new submissions
Participating nodes listen for newly published objects. Rather than treating every object as an independent item that must eventually be reproduced in full on-chain, the nodes collect the submissions and prepare to aggregate their verification results.
3. Nodes generate aggregation proofs
At each aggregation interval, a node can generate a STARK proof containing a collection of claims about the objects it has received.
Examples of these claims include:
The node also generates a proof demonstrating that the underlying signatures, STARK proofs, or PCS openings support the claims.
4. Aggregation proofs are combined recursively
The aggregation process does not necessarily stop after one round. Newly generated proofs can themselves be aggregated into larger proofs.
Through repeated aggregation, multiple verification results can eventually be represented by a single master proof associated with a block.
5. The block contains compact verification information
Under the described design, the chain would not need to receive every original signature or proof in its full form. Instead, it could receive the relevant claims, compact representations such as hashes of inputs and outputs, and the aggregate proof needed to verify them.
The goal is to reduce the amount of cryptographic data that must be repeatedly broadcast and processed while preserving the ability to verify the underlying statements.
This is an important distinction: aggregation does not mean that the network stops checking cryptographic validity. It changes how the evidence supporting that validity is organized and presented.
The mempool is important because it provides an opportunity to combine information before transactions and associated data are finalized into a block.
Without aggregation, a network may need to handle many separate cryptographic objects. With the proposed approach, nodes could process those objects in groups and produce proofs that attest to multiple verification results.
This could make the overall verification process more efficient, particularly when the original objects are large but the statements that need to be established are relatively compact.
However, aggregation also introduces technical requirements. Nodes need a reliable way to receive objects, construct valid proofs, and ensure that the final aggregate represents the correct set of claims. The protocol must also define how the relevant information is incorporated into blocks and how participants can independently verify it.
The potential benefits therefore depend on implementation details, not merely on the existence of a proof aggregation mechanism.
Vitalik’s November 16 post focused on three approaches associated with the broader EIP-8288 direction: leanSPHINCS, leanSTARK, and leanPCS.
Although all three relate to cryptographic verification, they differ in the type of object users generate and the degree of flexibility they offer.
Understanding these differences helps explain why Vitalik has become more optimistic about leanPCS.
leanSPHINCS is based on SPHINCS, a hash-based digital signature construction designed to provide post-quantum security.
Hash-based signatures rely on the security properties of cryptographic hash functions rather than the elliptic-curve assumptions used by conventional ECDSA signatures. This makes them relevant to research into quantum-resistant account authorization.
Under the leanSPHINCS approach described by Vitalik, users could create quantum-safe accounts while paying a relatively small amount of gas for signature verification. He cited a cost of approximately 4,096 gas for 64 bytes in the described context.
The main advantage is specialization. The approach is designed around a particular class of signature schemes, which means it does not require the same level of general-purpose computational flexibility as the other two approaches.
However, this is also its limitation. A mechanism optimized for one signature scheme cannot automatically support every possible cryptographic computation.
For applications that need a specific post-quantum signature option, leanSPHINCS could provide a more direct path. For broader applications involving privacy protocols, arbitrary computation, or alternative signature systems, a more general mechanism may be preferable.
leanSTARK takes a more flexible approach. Instead of requiring users to generate one particular type of signature, it allows them to run a computation and publish a STARK proof demonstrating that the computation was performed correctly.
This generality could support a wider range of applications, including:
The flexibility is significant because it could allow developers to build different cryptographic applications around a shared verification mechanism.
However, leanSTARK introduces a major coordination challenge: the protocol needs to define the language in which users write the programs being proved.
Vitalik referred to this as the instruction set architecture, or ISA.
An ISA specifies the instructions and computational model supported by a system. In this context, standardizing the ISA would establish the rules under which users can express computations for the proof system.
This is not a minor implementation detail. It affects what developers can prove, how programs behave, and how the system may evolve.
The Ethereum community would need to agree on the design, and changing a standardized instruction set later could be difficult. It is therefore understandable that a general-purpose leanSTARK implementation could require considerable discussion and engineering work.
The benefit is broad programmability. The trade-off is that Ethereum may need to resolve a substantial standardization challenge before the approach can be implemented.
PCS stands for polynomial commitment scheme. It is a cryptographic mechanism that allows a prover to commit to a polynomial and later provide evidence about its evaluation at a particular point.
In simplified terms, a polynomial commitment allows a party to establish a relationship between a polynomial and a claimed output without requiring the verifier to receive and evaluate the entire polynomial directly.
Polynomial commitment schemes are important components of many modern proof systems, including STARK-related constructions.
Vitalik’s explanation of leanPCS centers on a key idea: if Ethereum provides an efficient way to verify the relevant polynomial commitment openings, users can build different proof systems around that capability.
From the perspective of the Ethereum Virtual Machine (EVM), EIP-8288 could provide access to what Vitalik described as a kind of “magic PCS oracle.” With this capability, verifying a STARK could potentially cost approximately 20,000–40,000 gas, depending on the design and configuration.
The key advantage is that leanPCS may require less standardization than leanSTARK.
Rather than first agreeing on a complete instruction set for arbitrary programs, the protocol would need to specify the relevant polynomial commitment framework. Vitalik noted that this can be based on a finite field, with a 128-bit binary field being a natural option, while more general constructions may also be possible.
This narrower standardization scope could make leanPCS easier to advance.
There is, however, a trade-off. Vitalik acknowledged that leanPCS may be less efficient on-chain than leanSTARK because multiple claims may be needed to establish a single result. On the other hand, it can offer greater flexibility off-chain, allowing developers to choose from a wider range of proof systems.
The distinction is not simply that one approach is better than another. It is about which technical decisions need to be made first and where the system places its computational costs.
| Approach | Underlying object | Main advantage | Main limitation |
|---|---|---|---|
| leanSPHINCS | Hash-based signature | A specialized path toward quantum-safe accounts | Limited to a particular signature approach |
| leanSTARK | STARK proof | General-purpose computation and broad flexibility | Requires agreement on a standardized ISA |
| leanPCS | Polynomial commitment opening | Flexible proof-system choices and potentially faster standardization | May require more on-chain claims and lower on-chain efficiency |
The comparison illustrates why leanPCS has attracted attention. It does not necessarily offer the lowest verification cost in every scenario, but it could provide a practical compromise between generality and implementation complexity.
In his November 16 post, Vitalik said his view of leanPCS had changed from strong skepticism to strong support over the preceding weeks.
His reasoning was not that leanPCS had eliminated every technical challenge. Rather, he highlighted the possibility of achieving much of leanSTARK’s generality without waiting for the Ethereum community to settle the full ISA design.
This is important because protocol development involves more than identifying the most efficient technical solution. A proposal must also be specified, reviewed, standardized, implemented, and tested.
The main obstacle associated with leanSTARK is the need to agree on the instruction set that users will employ to express computations.
A general-purpose proof system could provide substantial flexibility, but its usefulness depends on the underlying computational language. Different design choices may affect performance, developer experience, security assumptions, and future compatibility.
Reaching agreement on these details can take time.
leanPCS offers a different sequencing strategy. It could establish a more limited cryptographic foundation first, allowing developers to use different proof systems without requiring the entire ISA framework to be finalized at the same time.
This does not remove the need for standardization. It changes the scope of what needs to be standardized before the first implementation can move forward.
leanPCS may require more on-chain verification work than leanSTARK for certain operations. At first glance, this could make it seem like a less efficient solution.
However, on-chain efficiency is only one part of the overall design.
A cryptographic system also needs to account for off-chain computation, implementation complexity, flexibility, and the time required to reach a stable specification.
Vitalik’s argument suggests that leanPCS could offer a more practical balance: somewhat greater on-chain overhead in exchange for more flexibility and a potentially shorter path to deployment.
For a technology roadmap that includes post-quantum security, this trade-off may be worth considering.
Another important point is that leanPCS and leanSTARK do not necessarily need to be competing, mutually exclusive approaches.
Vitalik suggested that leanPCS could be implemented first, with leanSTARK potentially added later after the ISA has been developed and agreed upon.
This creates a possible staged development path:
This approach could allow Ethereum to make progress on cryptographic verification without waiting for every component of a broader architecture to be finalized.
It remains a proposed development direction, however, rather than a confirmed implementation schedule.
If the proposed approach can be implemented securely and efficiently, its implications could extend beyond replacing one signature scheme or reducing the size of individual proofs.
The broader objective is to make Ethereum more capable of handling cryptographic operations that are expensive to transmit or verify individually.
One potential application is the migration toward post-quantum account security.
If quantum-resistant signatures are substantially larger than conventional signatures, simply replacing existing signature schemes could increase the amount of data associated with account authorization.
Proof aggregation could help address this challenge by allowing the network to verify claims about signatures without requiring every original signature to be repeatedly included in full.
This could be relevant to regular accounts, multisignature wallets, and other account authorization systems.
However, a quantum-safe signature mechanism is only one part of a broader security transition. Ethereum would also need to consider key management, wallet compatibility, account migration, recovery procedures, and the security of the underlying proof system.
EIP-8288 should therefore be viewed as a potential infrastructure component, not a complete solution to quantum risk.
The generality offered by leanSTARK and leanPCS could also support applications that require more complex authorization logic.
For example, a user might want to authorize transactions based on conditions that depend on private information or state that should not be publicly linked across multiple accounts.
A proof system could demonstrate that the authorization conditions have been satisfied without exposing the full logic or underlying data.
This could support more sophisticated privacy-preserving applications and account abstraction designs.
The potential benefits would depend on how developers implement these systems and what information the protocol ultimately requires them to disclose.
Proof aggregation could also help applications that generate many cryptographic objects.
Instead of requiring each object to be handled independently at the block level, multiple verification results could be represented through an aggregate proof.
This may be useful in areas such as rollup verification, privacy protocols, and other applications involving repeated cryptographic computations.
It is important to distinguish this from a general increase in Ethereum’s transaction throughput. EIP-8288 focuses on the handling and verification of cryptographic information. Any broader scalability benefits would depend on the specific workloads, implementation, and interaction with other protocol components.
Several questions remain before the proposed approach can be treated as an established part of Ethereum’s infrastructure.
Protocol specification: The exact rules for proof generation, aggregation, verification, and block integration need to be clearly defined.
Security review: The cryptographic constructions and aggregation process must undergo rigorous analysis. A compact proof is useful only if the network can trust the assumptions and verification procedure behind it.
Node requirements: The design needs to account for the computational and bandwidth requirements placed on participating nodes. Moving work into the mempool does not automatically make that work inexpensive.
Implementation and testing: Developers need to evaluate how the mechanism performs under realistic network conditions, including high submission volumes and different types of cryptographic objects.
Community coordination: Changes affecting Ethereum’s execution and verification environment require technical review and coordination across developers, researchers, infrastructure providers, and other ecosystem participants.
These considerations explain why Vitalik’s support for leanPCS is significant as a research and design signal, but should not be interpreted as confirmation that the proposal is already available to Ethereum users.
Ethereum’s exploration of EIP-8288 reflects a broader effort to prepare the network for future cryptographic requirements.
For developers and users, following this work means looking beyond individual proposal announcements and understanding how different parts of the security roadmap fit together.
An Ethereum Improvement Proposal describes a potential change to the protocol or its surrounding standards. The existence of an EIP does not mean that the proposal has been approved, scheduled, or deployed.
Readers should distinguish between a research discussion, an EIP specification, a proposal being considered for a network upgrade, and an implementation that has been activated on mainnet.
For EIP-8288, the technical explanation from Vitalik provides insight into the intended direction and the trade-offs among the three approaches. The proposal’s actual development status should be checked through its official specification and Ethereum developer discussions.
A quantum-resistant signature scheme is designed to withstand attacks from quantum computers. However, making an entire blockchain ecosystem quantum-ready requires more than adopting a new signature algorithm.
Wallets, smart contracts, account authorization, infrastructure, and user migration processes may all need to be considered.
Similarly, proof aggregation can help manage the additional data associated with some cryptographic systems, but it does not independently guarantee that every component of Ethereum is protected against quantum attacks.
A comprehensive transition requires coordinated changes across the cryptographic and application layers.
As the research progresses, several practical indicators will help clarify its value:
These measurements will help determine whether leanPCS provides the expected balance between flexibility, implementation complexity, and verification efficiency.
EIP-8288 is associated with an approach to scaling cryptographic verification on Ethereum through proof aggregation. The concept involves collecting cryptographic objects, generating proofs that verify multiple claims, and combining those proofs so that the chain can verify a more compact representation rather than receiving every original signature or proof in full.
PCS stands for polynomial commitment scheme. leanPCS is an approach that uses polynomial commitment openings as the underlying objects users generate and publish. It aims to provide a flexible foundation for different proof systems while potentially requiring less standardization than a general-purpose leanSTARK implementation.
leanSTARK allows users to generate STARK proofs for arbitrary computations, offering broad flexibility but requiring agreement on a standardized instruction set architecture. leanPCS focuses on polynomial commitment openings, which can support different proof systems with greater off-chain flexibility. Vitalik considers leanPCS potentially easier to implement sooner, although it may be less efficient on-chain in certain cases.
SPHINCS is a hash-based signature construction designed to resist attacks from quantum computers. leanSPHINCS applies this type of signature approach to Ethereum-related verification. Its main advantage is a specialized route toward quantum-resistant account signatures, while its scope is narrower than the more general leanSTARK and leanPCS approaches.
No. EIP-8288 and the lean approaches discussed by Vitalik represent a potential direction for improving cryptographic verification and supporting future post-quantum systems. They do not establish that Ethereum has completed a transition to quantum-resistant cryptography. A broader transition would involve multiple protocol, wallet, and infrastructure considerations.
Proof aggregation could reduce the amount of data and verification work required on-chain for certain cryptographic operations. However, the actual gas impact depends on the implementation, proof type, aggregation design, and workload. It should not be interpreted as a guarantee that all Ethereum transactions or smart contract operations will become cheaper.
Vitalik’s November 16, 2026 post explains why he now supports leanPCS as a potential development direction. It does not confirm that leanPCS or EIP-8288 has been implemented on Ethereum mainnet. Readers should consult official Ethereum development resources for the latest specification, testing, and deployment status.
Vitalik’s main reason is that leanPCS could provide much of the flexibility associated with leanSTARK without requiring the Ethereum community to first agree on a complete instruction set architecture. Although leanPCS may involve additional on-chain work in some cases, its narrower standardization requirements could make it a more practical first step.
This is not investment advice. This information is provided for informational purposes only and should not be construed as a recommendation to buy, sell or hold any asset. Cryptocurrency trading involves a risk of loss.
Gate US services may be restricted in certain jurisdictions. For more information, please see our legal disclosures: https://www.gate.com/en-us/legal/disclosures





