Author: Vitalik Buterin
Translated by: Jiahua, ChainCatcher
Can Ethereum achieve scalability while maintaining decentralization? Recent discussions among developers around this goal have been sparked by EIP-8037.
The proposal aims to significantly increase Ethereum's transaction execution capacity while controlling the growth of state data. To this end, it plans to raise the gas costs for creating new accounts, storage slots, and contract code. However, this adjustment may also impact certain applications and cross-chain bridges that use fixed gas parameters, requiring developers to complete fixes before the upgrade.
In this article, Vitalik explains why Ethereum’s different resources 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 consume node storage space, representing a more challenging scalability bottleneck.
- According to estimates in the text, if the gas limit increases tenfold without implementing EIP-8037, the growth rate of Ethereum's state data could rise from about 110 GiB per year to approximately 1100 GiB.
- EIP-8037 aims to increase the cost of state creation and introduce a state gas reserve mechanism, thus freeing up space for execution capacity expansion. However, some applications may still be affected by changes in gas costs.
- Vitalik stated that most core developers currently lean towards collaborating with application developers to identify and fix affected applications before launching Glamsterdam.
- For non-upgradable contracts, Vitalik advises developers not to assume that gas pricing and gas mechanisms will remain unchanged forever. He also urges core developers to compile a “blacklist” and “whitelist” of protocol rule changes to establish clearer expectations with application developers.
Below is the original translation:
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 Ethereum’s different resources: significantly increasing 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 scaling with security.
This article will discuss:
- The reasons behind the design of 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 future measures, as well as the inevitable limitations when addressing similar issues;
- Why there are discrepancies in expectations between core developers and application developers regarding future EVM changes;
- What rules developers of non-upgradable contracts and applications should follow to respond to changes in Ethereum’s future roadmap.
Different resources of 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: What problems will arise if the gas limit is simply raised without other changes?
Currently, the Ethereum network mainly faces the following resource burdens:

The simplest estimation method is: if the gas limit increases tenfold, the aforementioned metrics will also increase by about tenfold.
Among these, an average verification time increase of tenfold is acceptable, even though it will bring some downsides, such as affecting nodes running on laptops. However, a tenfold increase in the other three metrics would be unacceptable.
Aside from Blob, scaling other parts of Ethereum will affect the latter three metrics:
- Expanding execution capacity will impact the worst-case scenario for block verification time;
- Expanding calldata capacity will affect block broadcast time;
- Expanding state capacity, especially by creating more new states, will accelerate the growth of state data. A larger state not only increases disk space requirements and prolongs initial synchronization times but also weakens the assurance of nodes completing full state synchronization and decreases the speed of state read/write during execution.
Next, let's see what impacts other proposals for Glamsterdam will have besides EIP-8037:
- EIP-7976: Raises the minimum cost of calldata from 40 gas for non-zero bytes and 10 gas for zero bytes to 64 gas per byte, thus reducing the maximum volume of calldata.
- EIP-7928: Achieves parallel validation via block-level access lists, shortening verification time and accelerating synchronization.
- EIP-8038: Increases the gas costs for state read/write operations.
- EIP-7732 (ePBS): Raises the maximum time for securely validating blocks from about 2 seconds to approximately half a slot, or 6 seconds, through pipelining.
Assuming the gas limit increases tenfold while implementing the above Glamsterdam proposals but not EIP-8037, the situation would change as follows:

From the table, it can be seen that execution capacity does not pose any obvious problems. The situation for calldata is also close to an acceptable range, and the EIP-8279 and EIP-8131 planned for introduction in the Hegota upgrade could further reduce the worst-case data volumes by approximately 1.6 times.
In addition, the proposed P2P network improvements are expected to significantly shorten broadcast times per MB of data, allowing for more room for scaling. If even more space is needed, EIP-8288 will also allow for moving signatures and proofs out of calldata.
Thus, from most of the aforementioned dimensions, Ethereum can actually safely increase the gas limit by more than tenfold after the changes in Glamsterdam and Hegota are completed. The only exception is the size of state data.
Different resource limitations require re-pricing
For about the past decade, Ethereum has followed a simple rule: the gas cost of one resource should reflect the actual burden it imposes on the network.
If resource A imposes a burden on the network that is ten times that of resource B, then the gas cost 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 originally only required 50 gas, and after multiple re-pricings, it successively increased to 200, 800, and 2100 gas.
EIP-8037 responds to the asymmetry between the scalability limits of different resources in accordance with this thinking. It significantly raises the costs associated with creating new states, including creating storage slots, codes, and accounts.
The table below organizes the data in this proposal and calculates the total costs:

It should be noted that state gas is not subject to the limit of about 16.7 million gas for a single transaction, so deploying a 24 KiB contract remains feasible.
EIP-8037 also introduces new rules to ensure that a corresponding cost must be paid whenever state is created, regardless of the method. For example, currently, when sending ETH through a transaction to create a new account, the specified cost of 25,000 gas for account creation defined before the Glamsterdam upgrade does not even need to be paid. After the implementation of EIP-8037, regardless of how the new account is created, it will require paying 183,600 state gas.
Furthermore, EIP-8037 allows for these gas costs to be increased further in the future. The initial value of the CPSB parameter that determines gas costs is set at 1530, and there are plans to continue to adjust this upwards as the gas limit increases.
This design reflects a common view: execution and calldata will become increasingly easier to scale, but the room for improvement for state data is limited.
Ultimately, a byte is just a byte. Moreover, before introducing new types of state, state data cannot be solved through sharding: block builders and nodes re-executing transactions require the complete state data to operate.
Are there other options besides EIP-8037?
In fact, there are four alternatives:
- Never scale Ethereum;
- Accept the centralization caused by oversized state data;
- Not raise the gas costs for creating states but lower the gas costs for all other operations except state creation;
- Through some mechanisms, shift the additional gas costs out of the execution path, allowing users to pay elsewhere.
The first option severely conflicts with the wishes of a large part of the Ethereum community.
The second option violates Ethereum's fundamental guarantees.
The third option was considered but ultimately dismissed, as the impact it caused could be even greater. Compared to only increasing the cost of one type of operation, this solution would require lowering the gas costs for all other operations, including opcodes, precompiled contracts, calldata, blobs, and logs. The scope of the resulting impacts, as well as unforeseen issues, would be greater.
Moreover, if one wishes to scale beyond three times, the costs of EVM operations like ADD and PUSH must fall below 1 gas, which requires the introduction of mechanisms that operate in units of one-thousandth of a gas.
Thus, what remains is the fourth option. EIP-8037 adopts precisely this line of thinking, though it can only address part of the problem.
How does the gas reserve mechanism work?
EIP-8037 intentionally moves further toward “multi-dimensional gas”: a single transaction can have multiple gas limits, corresponding respectively to execution gas and state gas reserves.
By default, the portion within the limit of about 16.7 million gas for a single transaction is considered execution gas, while the portion exceeding this limit serves as a reserve. EIP-8141, also known as the framed transaction proposal, will allow users to set these limits more explicitly, so they do not need to prepare a balance in their account sufficient to cover more than 16.7 million gas to use the reserve mechanism.
When creating states, the system will prioritize deducting from the state gas reserve; only when the reserve is exhausted will it consume execution gas.
Sub-calls can utilize the entire state gas reserve. Therefore, the parent call can restrict the execution gas available to the sub-call but cannot restrict the state gas reserve available to the sub-call.
This mechanism bears similarities to the access list mechanism introduced by EIP-2930. Previously, EIP-2929 elevated the costs of storage reading, causing some contracts to malfunction; EIP-2930 allows users to prepay storage reading fees at the start of a transaction, making related operations cheaper during execution.
The gas reserve mechanism can address several issues:
First, it allows for the creation of large contracts that consume far more than the single transaction limit of 16 million gas.
Second, for operations requiring fixed gas calls but needing to create new storage slots, they can continue to run by including them in transactions with a gas limit exceeding 16 million.
It also supports a calling scenario: the parent call provides gasleft - N gas to the sub-call, ensuring that even if the sub-call exhausts gas, the parent call still retains N gas to carry out subsequent work.

For example, if the parent call provides gasleft - 100000 gas to the sub-call, even if the sub-call exhausts gas, the reserve mechanism can protect the remaining gas after execution ends in the same manner.
In the future, this mechanism will also allow Ethereum to calculate the upper limit, target values, and even gas prices for the entire block along different gas dimensions. For example, state creation, execution, and state read/write can be separately set with reserves while maintaining a generic dimension visible to sub-calls.
Essentially, this is a relatively less problematic solution when introducing multiple gas dimensions into the EVM. I regarded this issue as one of the most challenging parts in my article discussing multi-dimensional gas in 2024.
What problems cannot be solved by the reserve mechanism?
The reserve mechanism does not solve all problems. Currently, significant issues mainly include:
First, using transactions that exceed 16 million gas is not a straightforward solution. EIP-8141 will allow framed transactions to explicitly set execution gas and state gas, making this process clearer, but it will not arrive until the next hard fork. Regardless, applications will need to invest a substantial amount of frontend development work to continue operating normally.
Second, the configuration of some applications is difficult to upgrade. For instance, in some cross-chain bridges, configurations that determine transaction or call parameters are located in hard-to-upgrade places.
Third, the state gas reserve is optional. In certain applications, attackers may exploit this to disrupt users maliciously.
For example, in the OP Stack cross-chain bridge mechanism, there is a hardcoded limit of 40,000 gas. An attacker could trigger an operation that exits the user's state by sending a transaction without reserves, causing what should have been a successful call to fail, yet 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 could potentially increase, and the increase may be substantial.
Fifth, some applications will be affected by the increased gas costs under EIP-8038. For example, the cost of SSTORE will rise from 5,000 gas to 12,100 gas, but there are no available reserve options.
Sixth, when using reserves, the GAS opcode may no longer accurately reflect the total gas consumed by sub-calls. This means that the UserOperation of ERC-4337 will struggle to directly utilize reserve gas unless custom features are added to handle a few observable special cases, such as contract creation.
What mitigating measures are there?
The aforementioned problems can be mitigated in the following ways:
- Change gas refunds to occur at the end of the transaction rather than immediately.
- Cancel EIP-8038, but accept that the available scalability will shrink by approximately 2.4 times.
- Immediately add a reserve for state read/write gas, as a supplement to the state creation gas reserve.
- Accelerate the promotion of EIP-8141, incorporating the basic EIP-8141 transaction type into Glamsterdam. As long as it is acceptable to operate without a memory pool for a few months, this work is quite easy and currently appears to be basically ready. This way, users do not have to set the transaction gas limit above 16 million to utilize reserves.
- Redefine “storage slot is empty” and “storage slot is zero,” and add an opcode to allow setting any contract's storage slot from an empty state to zero.
- Modify the calling logic so that sub-calls always receive all gas from parent calls. This way, if the sub-call exhausts gas, the entire transaction, or the whole frame in EIP-8141, will roll back. This could resolve issues with the OP Stack cross-chain bridge but would destroy many other functionalities far beyond EIP-8037, such as ERC-4337 which would not be able to continue operating. EIP-8487 and some previous oil-and-gas proposals are milder versions of this idea but carry similar risks.
- Allow older contracts not to be bound by the new rules, like EIP-8488. This approach may be feasible, but to avoid impacting the overall goals of limiting resource consumption, corresponding penalty rules are needed to offset gas advantages arising from the old rules. For example, calling an old rule contract using N gas may incur an additional cost of 5N gas.
As for “implementing EIP-8037 but initially adopting milder parameters,” unfortunately, this does not solve the problem. The constraints of the OP Stack cross-chain bridge are very tight; even a slight increase in gas costs for state creation would make the costs of related operations exceed 40,000 gas.
Overall, each of these mitigation measures involves significant deep changes and may also introduce other compatibility risks that we have yet to consider.
The only relatively mild change is to place refunds at the end of transactions. However, it can only save a small portion of affected applications; and with Glamsterdam already advanced to the current stage, there remains a significant disparity in development and operational costs between “no changes” and “making one change.”
How should affected applications be handled now?
Ethereum scaling itself means that the degree of scaling for different resources will vary.
Execution, i.e., computation, is relatively easy to scale; the scaling difficulty of state read/write and calldata is moderate; while scaling state data size is the most challenging. To allow different resources to scale at different speeds, relative gas costs between them must be adjusted. EIP-8037 and EIP-8038 are already close to achieving this goal in a relatively less problematic manner.
There are indeed some mitigation solutions at the protocol level, but these solutions will incur significant costs to the development process, have their own risks, and may severely delay scaling and quantum security-related efforts.
Therefore, most core developers currently believe that the more favorable approach for security and progress is to focus primary efforts on another path: closely collaborating with application developers to ensure all applications affected by EIP-8037 and EIP-8038 can be effectively fixed before the launch of Glamsterdam.
This includes:
- Postponing the launch of Glamsterdam, which has already been completed;
- Openly communicating related issues, which has already been carried out through multiple public discussions and meetings;
- Investing resources to identify and rectify all problems, with relevant work already underway.
How can non-upgradable contracts cope with future changes?
Application developers may reasonably question the following situation:
I want to write non-upgradable contracts, meaning I do not set upgrade keys controlled by centralized entities or governance mechanisms. The meaning of Ethereum is to provide applications with strong guarantees for users.
So, if I want to ensure my contract does not become obsolete in the next hard fork, what should I do?
In this case, the answer is: do not assume gas pricing will never change.
Among seasoned Ethereum core developers and security communities, this has been a prevalent view for many years. Past articles by Matt Garnett and Martin Swende have discussed this aspect as well.
However, I believe the issue this time lies in the assumption by senior core developers that the idea of “not assuming gas pricing will not change” is already common knowledge, while failing to realize that this consensus has not been formally outlined or repeatedly emphasized since 2021.
Consequently, many newer developers, who are less closely connected to core developers, may not be aware that this is also a background assumption on which the designers of EIP-8037 relied.
In my view, the correct approach in the future is to more formally outline these “unwritten rules”: reach a clear consensus on which functionalities in the protocol may change and sufficiently communicate this to the outside world, making it a genuine common understanding among developers.
I believe this is feasible. Because the long-term roadmap of Ethereum, the Strawmap, is already quite mature, reliable predictions can be made regarding changes that may lead to compatibility issues.
Here are some Ethereum functionalities that I personally expect may change:
Various gas mechanisms. In general, any gas limit should be determined by the party that would bear the losses if settings are wrong.
In most cases, applications have actually been following this principle without much thought: if a transaction's gas is insufficient, the user bears the loss, while the transaction gas limit is controlled by the user's wallet. What needs to be done next is to apply this logic more broadly instead of hardcoding gas limits into applications.
I also suggest developers not to assume that “sub-calls can receive less than all gas” will remain a long-term capability. After the implementation of EIP-8141, this mechanism may eventually be removed to simplify the protocol, as all known related use cases can be realized within framed transactions.
State tree and block hash.
State is likely to shift towards partitioned binary trees based on Keccak, and the structure of blocks and receipts may also transition to a Keccak-based SSZ format.
The domain used for evaluating blob points.
Currently, an approximately 253-bit BLS-12-381 inner domain is used, which may change in the future to a 128-bit binary field.
Other changes to blob structures.
With changes in the used domain, the maximum size of a blob may increase to 2¹⁷ bytes and more significant adjustments may occur.
ECRECOVER precompiled contracts.
This functionality is expected to become stateful to ensure that accounts upgraded to quantum-safe schemes do not continue to expose risks via off-chain pre-authorization mechanisms.
Various mechanisms at the consensus layer.
Over the next two years, consensus algorithms are likely to undergo substantial adjustments. Validator participation mechanisms, rewards and penalties, distributed validator technology (DVT), light client protocols, etc., may all change.
Slot time.
As slot times shorten, using block.slot to approximate timestamps will no longer be effective.
The feasibility of distributed block construction strategies.
ePBS and FOCIL are likely to bring about significant changes, and more adjustments may emerge in the future.
Transaction formats.
Old transaction types may ultimately be phased out. Years from now, Ethereum may only support EIP-8141 transactions that use SSZ serialization.
Although new instruction set architectures could be introduced within the protocol, e.g., RISC-V or better solutions, I did not include the entire EVM in the above list.
The reason being that under such architectures, known methods already exist to add compatibility layers for the EVM, allowing it to continue executing as before, with gas costs being the only exception that may change.
This list is merely a result I compiled after several hours of contemplation. Ideally, core developers should collectively create a more comprehensive “blacklist” of functionalities expected to change; a “whitelist” of functionalities that are extremely unlikely to change would also be beneficial.
Most items are quite technical, and “simple” applications typically do not need to involve these issues. For example, applications like Uniswap have no reason to be affected. However, many edge cases still exist, so we need to proactively start this work as early as possible.
免责声明:本文章仅代表作者个人观点,不代表本平台的立场和观点。本文章仅供信息分享,不构成对任何人的任何投资建议。用户与作者之间的任何争议,与本平台无关。如网页中刊载的文章或图片涉及侵权,请提供相关的权利证明和身份证明发送邮件到support@aicoin.com,本平台相关工作人员将会进行核查。