Vitalik's New Piece: Why Is EIP-8037 the Only Path Forward for Ethereum Scaling?
- Core Thesis: EIP-8037 aims to decouple "compute scaling" from "state scaling" in Ethereum's scaling roadmap. By significantly raising the Gas cost of creating new state, it suppresses state bloat and stands as the most viable solution balancing security and scalability—but application developers must complete compatibility fixes before the Glamsterdam upgrade.
- Key Elements:
- Ethereum can withstand a 10x or greater Gas limit increase across dimensions such as compute, calldata, and broadcasting—but state growth is the "Achilles' heel" that cannot be simply sharded.
- EIP-8037 sharply raises the cost of creating new storage slots, deploying contracts, and creating new accounts. State Gas is not counted toward the per-transaction 16.7 million Gas cap, and 24KB contract deployments remain feasible.
- Supporting proposals include EIP-7976 (calldata price increase), EIP-7928 (block-level access lists), EIP-8038 (state read/write price increases), and EIP-7732 (ePBS, extending validation windows to 6 seconds).
- The state Gas reservoir mechanism supports large contract deployments and sub-call backstopping, but legacy issues remain: GAS opcode accounting distortions, ERC-4337 compatibility difficulties, and cross-chain bridges hardcoding Gas limits.
- The mainstream view among core developers is to delay the Glamsterdam upgrade, communicate publicly, and collaborate on fixing affected contracts—rather than making high-risk protocol-level overhauls.
- Vitalik emphasizes "do not assume Gas pricing is permanent," calls for formalizing unwritten rules, and lists expected future changes (Gas mechanisms, state trees, Blob structures, ECRECOVER, consensus layer, slot times, etc.).
Original author: Vitalik Buterin
Original translation: Luffy, Foresight News
The goal of EIP-8037 is to separate and handle Ethereum's two types of scaling bottlenecks: allowing execution-layer compute to increase significantly (compute scaling is relatively easy), while keeping state data growth to a very small amount (state scaling is very difficult).
This is the most viable approach at present that balances scaling and security. This article will:
- Explain the underlying logic behind introducing EIP-8037
- Explain why a scheme like EIP-8037 is almost the only way forward for Ethereum to scale securely
- Discuss ways to mitigate the drawbacks of this scheme: measures already implemented, measures that could be added, and which problems are inherently impossible to eradicate in similar schemes
- Talk about communication issues: why developers have misaligned expectations about future EVM changes
- Answer one question: what rules should developers writing non-upgradeable contracts and applications follow to ensure contract safety across all future upgrades in the strawmap.org roadmap
Background: The Carrying Capacity Limits of Different Ethereum Resources
Over the past decade, Ethereum has had two recognized core goals: 1) maintain decentralization and security; 2) achieve scaling.
To scale without sacrificing security and decentralization, we first need to understand Ethereum's resource constraints: if we simply raise the Gas limit and change nothing else, where would problems arise?
The Ethereum network currently has to bear pressure from several types of resources:

A simple estimate: if the Gas limit is increased 10x, the pressures above will basically all increase 10x in tandem. A 10x increase in average verification time is still acceptable (a laptop node would struggle but could still run); but a 10x increase in the remaining three items is unacceptable.
Apart from the Blob data approach, any Ethereum scaling action affects the latter three items:
- Scaling execution-layer compute → raises worst-case block verification time
- Scaling call data (calldata) → raises block propagation time
- Scaling state (new storage, new accounts) → state size balloons. The larger the state size, the higher the disk usage, the slower node sync, the harder full sync becomes, and the slower the execution layer reads and writes state
Let us look at the other proposals in the Glamsterdam upgrade package besides EIP-8037:
- EIP-7976: raises the base unit price of call data (non-zero bytes 40→64 Gas, zero bytes 10→64 Gas), compressing the maximum call data size per transaction
- EIP-7928: block-level access lists, supporting parallel verification, shortening verification time and speeding up node sync
- EIP-8038: raises the Gas cost of state read and write operations
- EIP-7732 (ePBS): extends the block safety verification limit from about 2 seconds to half a Slot (6 seconds)
Let us update the comparison table, assuming the Gas limit is raised 10x and the above proposals go live, but EIP-8037 does not:

Compute execution is fine. Call data pressure is also close to manageable; subsequent EIP-8279 and EIP-8131 (within the Hegota plan) can further reduce worst-case overhead, and peer-to-peer network optimizations will continue to lower propagation latency; EIP-8288 can also move signatures and proofs out of call data, further freeing up space.
In other words, in the dimensions of compute, call data, and propagation, combined with the Glamsterdam and Hegota upgrades, Ethereum could even withstand a Gas limit higher than 10x. The one fatal weak point is state size growth.
When One Type of Resource Bottleneck Is More Severe, Gas Must Be Repriced
For more than a decade, Ethereum has followed a principle: the Gas price of an operation should match the actual burden it places on the whole network. If operation A places 10x the burden of B on the network, the Gas price should be set at a 10x difference. The most typical example is SLOAD (reading storage), which has seen multiple price increases starting from EIP-150 through EIP-1884 and EIP-2929.
EIP-8037 is precisely a repricing aimed at the imbalance in resource pressure described above: sharply raising the cost of creating new state, whether adding new storage slots, deploying contracts, or creating new accounts. Below is the cost comparison given in the proposal:

State Gas does not count toward the 16.7 million Gas limit per transaction, so deploying a 24KB contract remains feasible
EIP-8037 also closes the rules: no matter how a new account is created (even just transferring ETH to a nonexistent address), this high state Gas must be paid, leaving no loopholes.
This pricing also supports further increases later: the initial value of the CPSB parameter that determines the state Gas base is 1530; when the Gas limit continues to rise later, this value can be raised further.
The core logical consensus is that the scaling space for compute and call data will continue to grow; but the ceiling for state scaling is very low. State is data that nodes must fully hold to run, and it cannot be simply sharded.
Are There Alternative Approaches?
In theory there are four paths:
- Ethereum stops scaling
- Accept unlimited state growth and move toward centralization
- Do not raise the Gas for creating new state; instead lower the Gas for all other operations
- Design a mechanism to separate this extra state cost from ordinary execution Gas and pay it separately
Options 1 and 2 conflict with the community's mainstream demands; Option 2 directly undermines Ethereum's underlying security promise; Option 3 has been discussed but rejected: the cost is greater. It would require lowering the price of all instructions, precompiled contracts, call data, Blob, and logs, introducing more unknown risks; moreover, after scaling beyond 3x, the unit price of basic instructions (ADD, PUSH, etc.) would fall below 1 Gas, requiring major protocol changes.
The remaining Option 4 is the path chosen by EIP-8037, though of course it can only solve part of the problem.
The State Gas Reservoir Mechanism
EIP-8037 is a step toward multidimensional Gas on Ethereum: a transaction has two Gas limits, one for ordinary execution Gas and another for the state Gas reservoir. By default, Gas within 16.7 million counts as execution Gas; the excess goes to the reservoir. EIP-8141 allows transactions to explicitly specify both limits, without requiring the account to hold a balance in advance to pay for Gas above 16.7 million.
New state creation operations first deduct state Gas from the reservoir; only when the reservoir is exhausted is ordinary execution Gas consumed. The reservoir is fully open to subcalls: a parent call can limit how much execution Gas a subcall may use, but cannot stop a subcall from using the reservoir.

This idea is very similar to EIP-2930. Back then, EIP-2929 price increases caused contract problems, and EIP-2930 introduced access lists, where users prepay storage read costs at the start of a transaction, making reads cheaper during execution. The reservoir mechanism solves several pain points:
- Supports large contract deployments that consume far more than 16.7 million Gas
- Calls with fixed Gas amounts that create new storage slots still run normally when wrapped in a transaction with a reservoir
- Parent calls reserve some Gas as a buffer: even if a subcall runs out of Gas, the parent call still has reserved Gas to finish; the reservoir mechanism also protects such finishing logic
In the long run, this framework supports setting Gas limits, target values, and Gas prices separately at the block level for different dimensions (new state, execution compute, state reads and writes), and the Gas reservoir can be extended into multiple dimensions. This is also the implementation with the least relative negative impact among the hardest problems I raised in my article "Multidimensional Gas" (https://vitalik.eth.limo/general/2024/05/09/multidim.html).
But the reservoir cannot solve all problems. The remaining core troubles are:
- The pattern of a single transaction exceeding 16.7 million Gas is inelegant. EIP-8141 will improve it, but it requires waiting for the next hard fork; application frontends will all need extensive adaptation work
- Some systems (such as cross-chain bridges) have transaction parameters hardcoded at the底层 (底层 is Chinese, should be "underlying layer" in English) level, making upgrade changes very difficult
- The reservoir is optional to use: for logic like the OP Stack bridge that hardcodes a 40,000 Gas limit, an attacker can send a transaction without a reservoir to trigger a state write, causing a call that should have succeeded to fail, while the transaction itself still confirms, achieving malicious harassment
- Gas refunds are changed to immediate refunds (EIP-3529 refunds uniformly at transaction end), so the return value of the GAS instruction may suddenly increase
- EIP-8038 separately raises the SSTORE cost (5000→12100), which has no reservoir mechanism as a buffer, so some contracts will already be affected
- Once the reservoir is used, the GAS instruction cannot accurately count the true total Gas consumed by subcalls; ERC-4337 UserOperations are hard to make compatible with the reservoir unless special adaptation logic is developed separately
For these pain points, there are some alternative remediation ideas, but each has costs:
- Revert to uniform refunds at transaction end: this only saves a small number of applications, and the cost of changing this close to Glamsterdam's launch is still very high
- Revoke EIP-8038: but this would directly compress the scaling ceiling by about 2.4x
- Add a reservoir for state reads and writes as well right now
- Accelerate the rollout of EIP-8141 and launch that transaction type directly in Glamsterdam (giving up mempool support in the short term)
- Distinguish between "empty storage slots" and "storage slots with value 0", and add a new instruction to zero out empty slots
- Change the rule: when a subcall runs out of Gas, roll back the entire transaction / entire call frame. This can fix the OP Stack bridge problem, but would break more existing systems (including ERC-4337)
- Grant exemptions to old contracts: but a penalty tax must be added, burning extra Gas when calling exempt contracts, to prevent bypassing state cost controls
There is another approach: launch EIP-8037 with gentler parameters first. But this approach is ineffective for the OP Stack bridge; even a small increase in state Gas would breach its hardcoded 40,000 Gas limit.
Overall, these remediation approaches are all deep protocol changes, carrying their own new risks and also delaying scaling and quantum-resistant upgrade progress. The mainstream view among core developers at present is to prioritize collaboration with application developers to fix all affected contracts before Glamsterdam launches, rather than continuing major protocol-level changes. Supporting actions include: delaying Glamsterdam (already implemented), public communication, and investigating and fixing issues (already underway).
What Should Application Developers Do Right Now?
Ethereum scaling is inherently "different resources scaling at different paces": compute is easiest to scale, state reads and writes and call data are medium difficulty, and state size is the hardest. To achieve differentiated scaling, the relative Gas costs of various operations must be adjusted; EIP-8037 + EIP-8038 is already the approach with the least negative impact.
Of course, we could also introduce some remediation approaches at the protocol level, but such approaches are extremely costly to develop, carry their own risks, and would seriously slow down scaling and quantum-resistant security upgrade progress. Precisely for this reason, the current view of the vast majority of core developers is: to balance security and development, the main effort should be placed on another path—working closely with application developers to ensure that all applications affected by EIP-8037 and EIP-8038 complete effective fixes before the Glamsterdam upgrade goes live.
Related measures include:
- Delaying the Glamsterdam upgrade (this has already been implemented)
- Publicly disclosing related issues (already underway, with multiple public discussions and online meetings organized)
- Devoting resources to investigating and fixing all affected issues (related work has already begun)
What Should Developers of Non-Upgradeable Contracts Do?
Application developers will have a very reasonable question: I want to write non-upgradeable contracts (that is, without upgrade permissions controlled by a centralized party or governance), since Ethereum's core value is providing users with applications that have this strong guarantee.
So if I want to write a contract that will not fail in the next hard fork, what exactly should I do?
For this incident, the answer is actually very clear: do not assume that Gas pricing rules are permanently fixed. In Ethereum's early core developer and security circles, this principle has been consensus for many years.
The crux of the matter is: early core developers assumed that "do not assume Gas prices never change" was common knowledge everyone should know, but they did not realize that after 2021, this lesson was never written down and repeatedly emphasized. As a result, a large number of developers who entered the industry relatively late and have limited information channels simply do not know that this is an assumed premise among the developer group that formulated EIP-8037.
In my view, the correct next step is to formally codify these "unwritten rules": reach a clear consensus, clarify which features in the protocol are allowed to change, and publicize it thoroughly so that it truly becomes industry consensus.
This is feasible because the strawmap.org roadmap is already quite mature, and all compatibility-breaking changes can be announced in advance with high accuracy.
Below is a list I have compiled of Ethereum features expected to change in the future:
- Everything related to the Gas mechanism. Generally speaking, the Gas limit should be set by the party that bears the loss from incorrect Gas settings. In most scenarios applications unconsciously follow this logic: when a user initiates a transaction with insufficient Gas, the user bears the loss, and the transaction Gas limit is controlled by the user's wallet. What remains is to fully implement this logic and not hardcode Gas limits in code. I also suggest that everyone not hold the assumption that "subcalls can be allocated less than the full Gas allowance"—this mechanism will be preserved permanently. After EIP-8141 launches, this mechanism will most likely eventually be removed to simplify the protocol.
- State tree and block hash scheme. In the future the state tree will most likely change to a Keccak-based partitioned binary tree, and block structures and receipts will also change to Keccak-based SSZ encoding format.
- The finite field used for Blob point evaluation. Currently it uses the BLS-12-381 roughly 253-bit field; in the future it will switch to a 128-bit binary finite field.
- Other changes to the Blob structure. Affected by the finite field change, the maximum capacity of a single Blob will be adjusted to a neat 2¹⁷ bytes; besides that, Blob may also undergo more substantial changes.
- ECRECOVER. It will become a stateful instruction in the future. This is to ensure that accounts upgraded to quantum-resistant versions will not remain exposed to risk due to off-chain pre-authorization mechanisms.
- Everything at the consensus layer. The consensus algorithm is very likely to undergo disruptive adjustments in the next two years. Validator participation rules, reward and penalty mechanisms, distributed validator technology (DVT), light client protocols, and so on will all change.
- Slot time. Block slot numbers can no longer be used as timestamps in the future, because Slot intervals will shorten.
- The feasibility of distributed block building schemes. ePBS, FOCIL, and subsequent upgrades will all continue to significantly change this mechanism.
- Transaction formats. Old transaction types will very likely be gradually phased out in the future; a few years from now, the only supported transaction format may be EIP-8141 transactions serialized with SSZ.
The EVM itself is not included in this list, even if the protocol底层 (底层 is Chinese, should be "underlying layer" in English) switches to a new instruction set in the future (such as RISC-V or a better option). The reason is that we already have mature solutions to add a compatibility layer in the new architecture, so that EVM code execution logic remains exactly the same as before. The only thing that will still change is Gas cost.
This list is just something I put together in a few hours. Ideally, core developers should collaborate to produce a more complete blacklist stating which features are expected to change, preferably accompanied by a whitelist marking which features are almost certain not to change. Most of the content in the list is technical, and ordinary applications will not encounter these pitfalls by default. But there are many


