Vitalik responds to the EIP-8037 controversy: Why does Ethereum need it for security scaling?
Author: Vitalik Buterin
Compiled by: Jiahua, ChainCatcher
Can Ethereum achieve scalability while maintaining decentralization? This goal has sparked discussions among developers regarding EIP-8037.
The proposal aims to significantly enhance Ethereum's transaction execution capacity while controlling the growth of state data. To this end, it plans to increase the Gas costs for creating new accounts, storage slots, and contract code. However, this adjustment may also affect some applications and cross-chain bridges that use fixed Gas parameters, requiring developers to complete fixes before the upgrade.
In this article, Vitalik explains why different resources in Ethereum need to be scaled separately, how EIP-8037 works, and the trade-offs faced by other alternatives. He also addresses application developers' concerns about contract compatibility and calls on core developers to clarify which protocol rules may change, allowing developers to prepare in advance.
Key points:
- Ethereum's computational execution capacity is relatively easy to scale, but state data continues to occupy node storage space, presenting a more challenging scalability bottleneck.
- According to estimates in the article, if the Gas limit is increased tenfold without implementing EIP-8037, the growth rate of Ethereum's state data could rise from approximately 110 GiB per year to about 1100 GiB.
- EIP-8037 plans to increase the cost of state creation and introduce a state Gas reserve mechanism to free up space for execution capacity scaling. However, some applications may still be affected by the adjustment in Gas costs.
- Vitalik states that most core developers currently prefer to collaborate with application developers to identify and fix affected applications before the launch of Glamsterdam.
- For non-upgradable contracts, Vitalik advises developers not to assume that Gas pricing and Gas mechanisms will remain unchanged forever. He also calls on core developers to compile a "blacklist" and "whitelist" of protocol rule changes to establish clearer expectations with application developers.
The following is the original compilation:
Special thanks to Binji, Lukasz Rozmej, and others for their feedback and review.
The goal of EIP-8037 is to separate the scalability limits of different resources in Ethereum: significantly enhancing the execution capacity, which is easier to scale, while only slightly increasing the growth of state data, which is harder to scale. This is the most feasible way to balance short-term scalability with security.
This article will discuss:
- The design rationale behind EIP-8037;
- Why solutions similar to EIP-8037 may be the only way for Ethereum to achieve secure scalability;
- How to mitigate the issues brought by EIP-8037, including measures already taken and those that can be taken in the future, as well as the inevitable limitations when addressing similar issues;
- Why there is a discrepancy in expectations between core developers and application developers regarding future EVM changes;
- What rules developers of non-upgradable contracts and applications should follow to cope with changes in Ethereum's subsequent roadmap.
Different Resources in Ethereum Face Different Limitations
Over the past decade, the two most important and widely recognized goals of Ethereum can be summarized as: maintaining decentralization and security while achieving scalability.
To achieve the latter without sacrificing the former, it is essential to understand Ethereum's resource limitations: if the Gas limit is simply increased without any other actions, where will the problems arise?
Currently, the Ethereum network primarily faces the following resource burdens:

The simplest estimation method is: if the Gas limit is increased tenfold, the above indicators will also increase by approximately tenfold.
Among them, an average verification time increase of tenfold is acceptable, although it will bring some drawbacks, such as affecting nodes running on laptops. However, an increase of tenfold in the other three metrics would be unacceptable.
Aside from Blobs, scaling other parts of Ethereum will affect the latter three metrics:
- Expanding execution capacity will affect the worst-case block verification time;
- Expanding calldata capacity will affect block broadcast time;
- Expanding state capacity, especially creating more new states, will accelerate the growth of state data. A larger state will not only increase disk space requirements and extend initial synchronization time but also weaken the assurance that nodes can complete full state synchronization and reduce the speed of state read and write during execution.
Next, let's see what impacts other proposals in Glamsterdam will bring, aside from EIP-8037:
- EIP-7976: Increases the minimum cost of calldata from 40 Gas for non-zero bytes and 10 Gas for zero bytes to 64 Gas per byte, thereby reducing the maximum volume of calldata.
- EIP-7928: Achieves parallel verification through block-level access lists, shortening verification time and speeding up synchronization.
- EIP-8038: Increases the Gas cost for state read and write.
- EIP-7732 (ePBS): Increases the maximum time for securely verifying blocks from about 2 seconds to about half a Slot, or 6 seconds, through pipelining.
Assuming the Gas limit is increased tenfold while implementing the above Glamsterdam proposals but not implementing EIP-8037, the situation would look like this:

From the table, it can be seen that there are no significant issues with execution capacity. The situation with calldata is also close to an acceptable range, and the EIP-8279 and EIP-8131 planned for introduction in the Hegota upgrade can further reduce the worst-case data volume by about 1.6 times.
Additionally, planned improvements to the P2P network are expected to significantly shorten the broadcast time per MB of data, freeing up more space for scalability. If even more space is needed, EIP-8288 will also allow signatures and proofs to be moved out of calldata.
Therefore, from most of the dimensions mentioned above, after the changes in Glamsterdam and Hegota are completed, Ethereum can actually safely increase the Gas limit by more than tenfold. The only exception is the size of state data.
Different Resource Limitations Require Repricing
For about the past decade, Ethereum has followed a simple rule: the Gas cost of a resource should reflect the actual burden it places on the network.
If resource A imposes a burden on the network that is ten times that of resource B, then the Gas costs of A or B should be adjusted so that the cost of A reaches ten times that of B.
The most typical example is SLOAD. It initially required only 50 Gas, and after several repricings, it was raised to 200, 800, and then 2100 Gas.
EIP-8037 follows this logic, addressing the asymmetry between the scalability limits of different resources. It significantly increases the cost of creating new states, including creating storage slots, code, and accounts.
The table below summarizes the data in this proposal and calculates the total cost:

It is important to note that state Gas is not subject to the single transaction limit of approximately 16.7 million Gas, so deploying a 24 KiB contract is still feasible.
EIP-8037 also introduces new rules to ensure that regardless of how a state is created, the corresponding costs must be paid. For example, currently, when creating a new account by sending ETH through a transaction, there is no need to pay the 25,000 Gas new account creation cost stipulated before the Glamsterdam upgrade. After the implementation of EIP-8037, regardless of how a new account is created, a cost of 183,600 state Gas will be required.
Furthermore, EIP-8037 allows these Gas costs to be further increased in the future. The initial value of the CPSB parameter that determines Gas costs is set at 1530, with plans to continue increasing it as the Gas limit rises.
This design reflects a common view: execution and calldata will become increasingly easier to scale, but the room for improvement in state data is limited.
Ultimately, a byte is a byte. Moreover, before introducing new types of states, state data cannot be resolved through sharding: block builders and nodes re-executing transactions need complete state data to operate.
Are There Other Options Besides EIP-8037?
In fact, there are four other options:
- Never scale Ethereum;
- Accept centralization caused by excessive state data;
- Do not increase the Gas cost for creating states but reduce the Gas costs for all operations other than state creation;
- Through some mechanism, move the additional Gas costs out of the execution path, allowing users to pay elsewhere.
The first option is in serious conflict with the wishes of a large portion of the Ethereum community.
The second option violates Ethereum's fundamental guarantees.
The third option was considered but ultimately rejected because its impact could be greater. Compared to only increasing the cost of one type of operation, this option would require lowering the Gas costs for all other operations, including opcodes, precompiled contracts, calldata, Blobs, and logs. The resulting scope of impact and unforeseen issues would be much larger.
Additionally, if scaling is desired beyond three times, the costs of EVM operations like ADD and PUSH must be below 1 Gas, which would require introducing a mechanism that uses one-thousandth of Gas as a unit.
Therefore, what remains is the fourth option. EIP-8037 adopts this approach, although it can only address part of the problem.
How Does the Gas Reserve Mechanism Work?
EIP-8037 intentionally moves further towards "multi-dimensional Gas": a single transaction can have multiple Gas limits, corresponding to execution Gas and state Gas reserves.
By default, the portion of a single transaction within the Gas limit of approximately 16.7 million Gas is considered execution Gas, while the portion exceeding this limit is treated as reserves. EIP-8141, the frame transaction proposal, will allow users to more clearly set these limits separately, without needing to maintain a balance sufficient to cover amounts exceeding 16.7 million Gas in their accounts.
When creating a state, the system will prioritize deducting fees from the state Gas reserves; only when the reserves are exhausted will execution Gas be consumed.
Subcalls can use the entire state Gas reserve. Therefore, the parent call can limit the execution Gas that the subcall can use, but it cannot limit the state Gas reserve that the subcall can use.
This mechanism is similar to the access list mechanism introduced by EIP-2930. Previously, EIP-2929 increased the cost of storage reads, causing some contracts to fail to operate normally; EIP-2930 allows users to prepay storage read fees at the start of a transaction, making related operations cheaper during execution.
The Gas reserve mechanism can solve several problems:
First, it allows the creation of large contracts that consume far more than the single transaction limit of 16 million Gas.
Second, for operations that use fixed Gas calls but require the creation of new storage slots, they can continue to run by placing them in transactions with a Gas limit exceeding 16 million.
It also supports a calling scenario: the parent call provides the subcall with gasleft - N Gas, ensuring that even if the subcall runs out of Gas, the parent call still retains N Gas to complete subsequent work.

For example, if the parent call provides the subcall with gasleft - 100000 Gas, even if the subcall runs out of Gas, the reserve mechanism can protect the remaining Gas after execution in the same way.
In the future, this mechanism will also allow Ethereum to calculate the limits, targets, and even Gas prices for the entire block based on different Gas dimensions. For instance, state creation, execution, and state read/write can all set reserves separately while retaining a common dimension visible to a subcall.
Essentially, this is a relatively less problematic solution when introducing multiple Gas dimensions into the EVM. I previously discussed this issue as one of the most challenging parts in my article on multidimensional Gas in 2024.
What problems cannot be solved by the reserve mechanism?
The reserve mechanism does not solve all problems. Currently, the major issues mainly include:
First, transactions using more than 16 million Gas are not a straightforward solution. EIP-8141 will allow frame transactions to explicitly set execution Gas and state Gas, making this process clearer, but it will not arrive until the next hard fork. In any case, applications will need to invest a lot of frontend development work to continue operating normally.
Second, some application configurations are difficult to upgrade. For example, in some cross-chain bridges, the configuration used to determine transaction or call parameters is located in hard-to-upgrade positions.
Third, state Gas reserves are optional. In some applications, attackers can exploit this to launch malicious disruptions against users.
For example, the OP Stack cross-chain bridge mechanism has a hardcoded limit of 40,000 Gas. Attackers may trigger operations that exit user states by sending transactions without reserves, causing what should have been successful calls to fail, but the system still records the operation as completed.
Fourth, the refund mechanism immediately returns Gas, rather than returning it at the end of the transaction as previously stipulated by EIP-3529. This means that the value returned by the GAS opcode may increase, and the increase could be quite significant.
Fifth, some applications will be affected by the increased Gas costs from EIP-8038. For example, the cost of SSTORE will increase from 5,000 Gas to 12,100 Gas, but there are no available reserve options here.
Sixth, when using reserves, the GAS opcode can no longer accurately reflect all the Gas consumed by the subcall. This means that the UserOperation of ERC-4337 will find it difficult to directly use reserve Gas unless custom functionality is added to handle a few observable special cases, such as contract creation.
What are the mitigation measures?
Some of the above issues can be mitigated in the following ways:
- Change the Gas refund to occur at the end of the transaction rather than immediately.
- Cancel EIP-8038, but accept that the expansion space will shrink by about 2.4 times.
- Immediately add a reserve for state read/write Gas as a supplement to the state creation Gas reserve.
- Accelerate the advancement of EIP-8141 by adding basic EIP-8141 transaction types in Glamsterdam. As long as it is acceptable not to support the memory pool for a few months, this work is easy and seems to be basically ready. This way, users do not need to set the transaction Gas limit above 16 million to use reserves.
- Distinguish between "storage slot is empty" and "storage slot equals zero," and add an opcode that allows any contract's storage slot to be set from empty to zero.
- Modify the calling logic so that subcalls always receive all Gas from the parent call. This way, if the subcall runs out of Gas, the entire transaction, or the entire frame in EIP-8141, will roll back. This can solve the OP Stack cross-chain bridge problem but will break many other functionalities, far more than EIP-8037, such as ERC-4337 will no longer operate. EIP-8487 and some previous oil-and-gas proposals are a milder version of this idea but carry similar risks.
- Allow old contracts to be exempt from new rules, such as EIP-8488. This approach may be feasible, but to avoid impacting the overall goal of limiting resource consumption, accompanying penalty rules are needed to offset the Gas advantages brought by old rules. For example, when calling a contract using old rules with N Gas, an additional 5N Gas is consumed.
As for "implementing EIP-8037 but starting with milder parameters," unfortunately, this does not solve the problem. The restrictions of the OP Stack cross-chain bridge are very tight, and even a slight increase in the Gas cost of state creation will cause the costs of related operations to exceed 40,000 Gas.
Overall, each of these mitigation measures involves significant deep changes and may bring other compatibility risks that we have not yet considered.
The only relatively mild change is to move the refund to occur at the end of the transaction. However, it can only save a small portion of the affected applications; given that Glamsterdam has progressed to its current stage, there is also a need to weigh the significant development and operational cost differences between "making no changes" and "making a change."
How should affected applications be handled now?
Ethereum's scaling itself means that the scaling extent of different resources will vary.
Execution, that is, computation, is relatively easy to scale; state read/write and calldata scaling are moderately difficult; state data size is the hardest to scale. To allow different resources to scale at different speeds, their relative Gas costs must be adjusted. EIP-8037 and EIP-8038 are already close to achieving this goal in a relatively less problematic way.
There are indeed some mitigation measures at the protocol level, but these measures will bring significant costs to the development process, have their own risks, and may severely delay scaling and quantum security-related work.
Therefore, most core developers currently believe that a more favorable approach for security and progress is to focus primary efforts on another path: closely collaborating with application developers to ensure that all applications affected by EIP-8037 and EIP-8038 are effectively fixed before the launch of Glamsterdam.
This includes:
- Delaying the launch of Glamsterdam, which has already been completed;
- Publicly communicating related issues, which has already been carried out through multiple public discussions and meetings;
- Investing resources to identify and fix all issues, with related work already underway.
How should non-upgradable contracts respond to future changes?
Application developers may reasonably ask this question:
I want to write non-upgradable contracts, meaning I do not set upgrade keys controlled by centralized entities or governance mechanisms. The essence of Ethereum is to provide applications with such strong guarantees for users.
So, if I want my contract not to fail in the next hard fork, what should I do?
In this case, the answer is: do not assume that Gas pricing will never change.
This has been a common viewpoint among senior Ethereum core developers and the security community for many years. Articles by Matt Garnett and Martin Swende in the past have also discussed this point.
However, I believe the issue this time is that the senior core developer community assumes that "do not assume Gas pricing will not change" is common knowledge, without realizing that this consensus has not been formally articulated or repeatedly emphasized since 2021.
As a result, many newer developers, who are less closely connected to core developers, do not know that this is also the background assumption on which the designers of EIP-8037 based their work.
In my view, the correct approach in the future is to more formally articulate these "unwritten rules": reach a clear consensus on which functionalities in the protocol may change and communicate this adequately to the outside world, making it truly a common understanding among developers.
I believe this is achievable. Because the current long-term roadmap of Ethereum, the Strawmap, is already quite mature, reliable predictions can be made about changes that may trigger compatibility issues.
Here are some Ethereum functionalities that I personally expect to change:
Various Gas mechanisms. Generally, any Gas limit should be determined by the party that will bear the loss in case of misconfiguration.
In most cases, applications have actually followed this principle without thinking: if the Gas for a transaction is insufficient, the one bearing the loss is the user, while the transaction Gas limit is controlled by the user's wallet. What needs to be done next is to apply this logic more universally, rather than hardcoding Gas limits into applications.
I also advise developers not to assume that the ability for "subcalls to receive less than all Gas" will exist long-term. After the implementation of EIP-8141, this mechanism may eventually be removed to simplify the protocol, as all currently known related use cases can be implemented in frame transactions.
State trees and block hashes.
States are likely to shift to partitioned binary trees based on Keccak, and block structures and receipts may also shift to Keccak-based SSZ formats.
Domains used for blob point evaluation.
Currently, the inner domain used is approximately 253 bits of BLS-12-381, which may change to a 128-bit binary field in the future.
Other changes to blob structures.
As the domain used changes, the maximum size of blobs may increase to 2¹⁷ bytes, and there may be larger adjustments.
ECRECOVER precompiled contracts.
This functionality is expected to become stateful to ensure that accounts upgraded to quantum-safe solutions do not continue to expose risks through off-chain pre-authorization mechanisms.
Various mechanisms at the consensus layer.
Over the next two years, consensus algorithms may undergo significant adjustments. Validator participation mechanisms, rewards and penalties, distributed validator technology (DVT), light client protocols, etc., may all change.
Slot time.
As the Slot time shortens, the method of using block.slot to approximate timestamps will no longer be effective.
Feasibility of distributed block construction strategies.
ePBS and FOCIL are likely to bring significant changes, and more adjustments may occur in the future.
Transaction Format.
Old transaction types may eventually be phased out. In a few years, Ethereum may only support EIP-8141 transactions using SSZ serialization.
Although new protocol internal instruction set architectures may be introduced in the future, such as RISC-V or better solutions, I have not included the entire EVM in the above list.
The reason is that under such architectures, there are already known methods to add compatibility layers for the EVM, allowing it to continue executing in the original way, with the only exception being that Gas costs may change.
This list is simply the result of a few hours of contemplation. Ideally, core developers should collaboratively create a more comprehensive "blacklist" listing features expected to change; it would also be best to create a "whitelist" listing features that are highly unlikely to change.
Most of these items are quite technical, and "simple" applications typically do not need to deal with these issues. For example, applications like Uniswap have no reason to encounter problems because of this. However, there are still many edge cases, so we need to proactively start this work as soon as possible.
ChainCatcher reminds readers to view blockchain rationally, enhance risk awareness, and be cautious of various virtual token issuances and speculations. All content on this site is solely market information or related party opinions, and does not constitute any form of investment advice. If you find sensitive information in the content, please click , and we will handle it promptly.
Popular articles












