Author: Vitalik Buterin
Translated by: Deep Tide TechFlow
Deep Tide Overview: The core contradiction of Ethereum scaling lies in resource heterogeneity: computational execution and network transmission can be efficiently scaled through hardware iteration and parallelization, while the unchecked expansion of the overall network state is strictly constrained by hardware storage and synchronization bottlenecks.
As the core proposal of the Glamsterdam upgrade, EIP-8037 introduces the state gas reservoir mechanism, significantly repricing the cost of state creation and decoupling execution scaling from state expansion for the first time on a systematic level. Although this breaks some old assumptions of hardcoded gas usage, it represents the only viable engineering path for Ethereum's secure scaling.

Special thanks to colleagues like Binji and Lukasz Rozmej for their feedback and reviews of this article.
The core goal of EIP-8037 is to decouple Ethereum's scaling boundaries: allowing for a substantial increase in easily scalable execution compute while strictly limiting the growth of state volume that is difficult to scale. This is the most pragmatic solution for balancing scaling capability and system security in the short term.
This article will focus on the following five topics:
· Elaborate on the core logic of advancing EIP-8037;
· Argue why mechanisms similar to EIP-8037 are essential for secure scaling of Ethereum;
· Explore coping strategies for potential compatibility issues with EIP-8037 (including existing progress, potential solutions, and the fundamental constraints behind the proposals);
· Analyze the communication gap between the core layer and application layer, reflecting on the expected mismatches in future EVM rule evolution;
· Provide a survival guide for developers writing immutable contracts and applications, detailing how to maintain contract security amidst future roadmap evolutions.
Background: Capacity Limits of Different Resource Types in Ethereum
Over the past decade, the two core goals most widely recognized by the Ethereum community can be summarized as: maintaining decentralization and security, and achieving scalability.
To achieve scaling without sacrificing decentralization, we must first clarify the carrying limits of various underlying resources in Ethereum: if we simply raise the gas limit without any other improvements, where will the system ultimately fail?
Below is the current major resource load status of the Ethereum network:

Figure: Current operating load baseline of major resource dimensions in Ethereum
If we make a simplistic linear extrapolation, increasing the gas limit by 10 times will cause all the above values to increase by 10 times simultaneously.
The first item (average verification time) is still bearable when increased 10 times (although it puts some pressure on staking nodes running on personal laptops), but enlarging the other three items by 10 times would lead to a disaster that the network absolutely cannot tolerate. Aside from blobs, any scaling of Ethereum’s execution layer will directly touch these three red lines:
· Scaling execution compute: directly increases block verification time in the worst case;
· Scaling calldata: directly increases the worst-case network broadcast transmission time;
· Scaling state (especially creating new state): directly leads to explosive growth of state volume. Larger states not only raise disk capacity and performance thresholds, significantly prolonging the initial synchronization time for full nodes but also weaken the network's certainty of successfully synchronizing the total state and slow down all state I/O read and write operations during daily execution.
Changes introduced by other proposals in Glamsterdam
Before discussing EIP-8037, let us first examine the improvements brought by several other core proposals in the Glamsterdam upgrade:
· EIP-7976: Raised the baseline cost of calldata from (non-zero byte 40, zero byte 10) to 64 per byte, effectively compressing the maximal calldata size per block;
· EIP-7928: Introduced block-level access lists (BAL), enabling parallel validation, significantly reducing verification time and improving synchronization speed;
· EIP-8038: Increased the gas cost of state I/O operations;
· EIP-7732 (ePBS): Through pipelined processing mechanisms, extended the security validation time window of a single block from about 2 seconds to about half of a Slot (i.e., 6 seconds).
Let us take these proposals into account and reassess the system load performance after a 10-fold increase in the gas limit:

Figure: System load performance prediction after implementing various optimizations in Glamsterdam with a 10-fold gas limit
The above data shows that there are now no major bottlenecks in the execution layer. Calldata transmission has also nearly met standards, and subsequent upgrades in Hegota's EIP-8279 and EIP-8131 will further reduce the worst volume by about 1.6 times.
With the planned P2P transmission optimizations, the network can easily gain additional bandwidth redundancy; if further expansion is needed, EIP-8288 will also support the separation of signatures and proofs from calldata.
Therefore, with the support of the Glamsterdam and Hegota upgrades, Ethereum is fully capable of withstanding a 10-fold or even greater increase in the gas limit in terms of computation and networking.
The only fatal bottleneck left in the entire system is the state volume.
When Resource Constraints are Asymmetrical: The Logic of Repricing
For nearly a decade, Ethereum has adhered to a simple and clear iron rule: the gas pricing of a certain resource must accurately reflect the actual physical burden it places on the underlying network. If resource A imposes a burden 10 times greater than that of resource B, the gas costs for either A or B must be dynamically adjusted so that A's expenditure reaches 10 times that of B.
The most typical historical example is the SLOAD instruction: it initially required only 50 gas, which was progressively repriced to 200, then 800, and ultimately adjusted to the current 2100 due to the actual hardware bottlenecks of state read and write operations.
In light of the severe asymmetry in resource carrying capacity discussed above, EIP-8037 does exactly the same: significantly increasing the cost of creating new states, whether it is adding storage slots, writing new code, or creating new accounts.
Below is the cost adjustment comparison suggested by EIP-8037 (already converted to the final total expenditure):

Figure: Pricing proposal for state creation operations by EIP-8037
It is important to note that state gas is not limited by the single transaction 16.7M execution gas limit, so deploying a full-size contract of 24 KiB can still proceed normally.
Furthermore, EIP-8037 also introduces a new logic to eliminate cost-avoidance loopholes. For example, under existing rules, creating a new account through a regular ETH transfer does not even require paying the 25,000 NEWACCOUNT expense; but after EIP-8037 is implemented, no matter how a new account is created, the full amount of 183,600 state gas must be paid without exception.
Moreover, EIP-8037 is designed to allow these state expenses to increase over time. The core parameter determining this cost, CPSB, is initially set at 1530 and will be raised in tandem with the increase in gas limits.
This design reflects the consensus of the core developer community: computation and data transmission will become increasingly easier to scale, but the physical limits of state storage are difficult to break. Before introducing a new paradigm for state, every byte of stored data is a tangible burden, and states cannot be easily sharded, as any block producer or replay node must possess the complete state data to function correctly.
Trade-offs of Alternative Solutions
Faced with the dilemma of state expansion, beyond repricing, there are actually only four alternative choices in engineering practice:
· Never scale Ethereum;
· Casually accept the centralization of nodes due to massive states;
· Do not increase the cost of state creation, but significantly lower the costs of all operations other than state creation;
· Introduce a dedicated mechanism to separate this additional gas cost from the execution path, allowing users to make payments in an independent dimension.
The first choice clearly violates the wishes of the vast majority of the Ethereum community; the second choice directly undermines the security promise that underpins Ethereum's establishment.
The third plan was explored in depth but ultimately rejected because its destructive consequences are far more severe than increasing prices: significantly lowering gas costs for all dimensions other than state would create unknown risks and chain reactions that are hard to estimate.
Moreover, achieving a scaling of over 3 times would necessitate lowering the costs of fundamental opcodes like ADD and PUSH to below 1 gas, forcing Ethereum to introduce a highly complex milli-gas mechanism.
Thus, the only path left is the fourth option: which is precisely the breakthrough thinking of EIP-8037, even though it can currently only address some derivative issues.
Design and Operation of the Reservoir Mechanism
EIP-8037 represents an important step for Ethereum towards "multi-dimensional gas." Under this mechanism, a single transaction can simultaneously specify gas limits across multiple dimensions: part for execution gas and another part as a state gas reservoir.
By default, all parts of a transaction within the 16.7M execution limit are classified as execution gas, while excess parts are automatically injected into the reservoir (subsequent EIP-8141 frame transactions will allow users to more explicitly define these two values without needing to forcefully achieve injections through inflated transaction gas limits).
Any operation involving state creation must first deduct fees from the state gas reservoir; only when the reservoir is depleted will it fallback and deduct from the regular execution gas. Importantly, the state gas reservoir is completely transparent and open to sub-calls: parent calls can strictly limit the execution gas allocated to child calls but cannot cut off child calls' access to the state gas reservoir.
This design thinking is highly akin to the access list mechanism introduced by EIP-2930: back then, raising the cost of storage reads in EIP-2929 caused some old contracts to break, EIP-2930 allowed users to pre-declare and pay for reading expenses in the transaction header, restoring cheaper reads within the execution path.
The reservoir mechanism successfully addresses the following core challenges:
· Allowing a single large contract deployment to use far more than the 16.7M execution limit gas;
· Allowing certain external calls with hardcoded fixed gas limits to operate normally, as long as the entire transaction is wrapped in a higher gas transaction with a reservoir;
· Allowing parent calls to invoke child contracts in a manner akin to gasleft - N, ensuring that even if the child call exhausts gas and produces exceptions, the parent call still retains adequate N gas to complete necessary post-fact state cleanup.
In the long run, this mechanism allows Ethereum to compute the overall block dimensions’ upper limits, target capacities, and dynamic gas pricing separately across different resource dimensions (state creation, ordinary execution, state I/O), providing a low-cost engineering solution to the multi-dimensional gas architectural challenges.
Edge Issues Not Resolved by the Reservoir
However, the reservoir is not a panacea, and the following types of compatibility issues still exist:
· Constructing ultra-large gas transactions is cumbersome: Before EIP-8141 is fully implemented, requiring the frontend to construct transactions exceeding 16.7M gas appears complex and necessitates substantial frontend renovation by application developers;
· Hardcoded configurations cannot be upgraded: Core applications like cross-chain bridges have transaction construction or call parameters hardcoded within modules that are difficult to upgrade;
· Reservoir injection is purely optional: Taking the OP Stack cross-chain bridge mechanism as an example, its underlying configuration contains a hardcoded gas limit of 40,000 gas. Malicious attackers can deliberately send a withdrawal transaction without a reservoir, maliciously exhausting calling gas and causing fund withdrawal failures, while external logic might mistakenly mark it as processed;
· Instant refunds disrupt gas measurement: The proposal switches to an instant refund mechanism rather than a unified settlement at the end of the transaction, leading to potentially abnormal large jumps in the remaining gas values returned by the GAS opcode;
· EIP-8038 lacks reservoir protection: EIP-8038 increased SSTORE costs from 5,000 to 12,100 and did not configure a reservoir, directly damaging a very few older applications;
· Hinders account abstraction: After using the reservoir, the GAS opcodes can no longer accurately track the total energy consumed by child calls, making it difficult for ERC-4337 abstract accounts to smoothly utilize reservoir gas.
In response to these pain points, the community has discussed various remedial measures at the protocol layer: such as restoring end-of-transaction settlement refunds, canceling EIP-8038 at the cost of narrowing scaling space by 2.4 times, and adding a reservoir for state I/O.
Other ideas include the early introduction of the EIP-8141 foundational framework, differentiating between null and zero storage slots, forcing child calls to rollback the entire frame if over-subscribed, or exempting old contracts (EIP-8488) etc.
However, objectively assessing, each of the foregoing remedial measures entails significant changes that may easily lead to unforeseen new vulnerabilities. The only relatively mild adjustment to instant refunds may only salvage a small number of affected applications; with the Glamsterdam upgrade entering late-stage testing, any protocol-level modification will significantly increase operational and delivery risks.
How should application developers respond today?
Ethereum’s scaling is essentially an asymmetric resource game. Pure computational execution is the easiest to scale, while state I/O and calldata follow closely, and the expansion of state volume is the most stringent.
To implement precise differentiated scaling across different resources, the system must dynamically reset their relative gas costs; and under current realistic engineering boundaries, EIP-8037 and EIP-8038 represent a compromise solution that is very close to optimal.
The core developer team evaluates that imposing various fragile patches on the protocol layer not only incurs extremely high development costs but also introduces unknown systemic risks, severely slowing the overall pace of quantum resistance upgrades and mainnet scaling.
Thus, a more pragmatic path is to focus primary energy on application layer collaboration: fully assisting the vast number of application layer developers in ensuring all applications and smart contracts affected by EIP-8037 and EIP-8038 complete adaptation and repair before the official launch of the Glamsterdam upgrade on the mainnet.
This includes:
· Actively delaying the launch window of Glamsterdam (already executed);
· Fully and transparently clarifying these potential technical impacts (with multiple public discussions and teleconferences already held);
· Investing dedicated ecological resources to assist in identifying affected projects and driving remediation (related work is underway).
Survival Rules for Immutable Contracts Facing the Future
In light of the recent upheaval, many developers have posed a perfectly reasonable and profound question: the core value of Ethereum is to empower users to have decentralized applications with strong assurances; writing immutable contracts without any admin upgrade private keys is so as to fulfill this promise. If the next hard fork could break the old rules at any time, how then should secure, perpetual smart contracts be written in the future?
The answer to this incident can really be summarized in one sentence: never assume that gas expenditure rules are eternal and unchanging.
In the early core development and security audit circles of Ethereum, this has always been a self-evident underlying consensus. However, this understanding has seldom been formally summarized and repeatedly preached since 2021, leading many new-generation developers who joined in subsequent cycles to never realize this was the default underlying assumption of the entire core developer community when advancing EIP-8037.
Looking to the future, we must formalize these self-evident unspoken rules: achieve a high degree of consensus within the entire ecosystem on which characteristics of the protocol layer belong to the mutable area and widely publicize them to make them public knowledge in the whole industry. Now, Ethereum’s development roadmap (Strawmap) has become highly clear and mature, allowing for relatively precise predictions of the characteristics that may undergo disruptive adjustments in the future.
Below is a list I personally organized of the characteristics that are expected to change in the future in Ethereum:
Any form of gas mechanism
When designing smart contracts, any specific gas limit should be dynamically set by the party bearing the losses due to erroneous limits. In the vast majority of scenarios, applications have already naturally executed this principle: if the transaction gas is insufficient, the one incurring the loss is the user sending the transaction, so the transaction gas limit is entirely chosen and set autonomously by the user's wallet.
The future needs to promote dynamic settings to all links, entirely abandoning the practice of hardcoding any specific gas numbers in contract code.
Moreover, developers are advised not to assume that sub-calls can always run below total gas: after EIP-8141 is implemented, to simplify the protocol, this mechanism may be completely removed as its use case can be achieved more elegantly within the Frame.
State tree and block hash structure
The current state tree is likely to be restructured into a binary partition tree based on Keccak, and the block structure and transaction receipts will fully transition to the Keccak-based SSZ serialization format.
Mathematical finite fields used for blob point evaluation
The current system employs approximately 253 bits of the BLS-12-381 inner field, which is highly likely to migrate to a 128-bit binary finite field in the future.
Subsequent evolution of the blob data structure
With changes in finite fields, the maximum size of a single blob is expected to be standardized to a full 131,072 bytes, and larger structural reorganizations might even be on the horizon.
ECRECOVER pre-compiled contract
To ensure that accounts upgraded to quantum-resistant cryptography in the future won't be subject to replay attacks due to historical chain off-chain pre-authorization vulnerabilities, ECRECOVER is expected to be redesigned as a stateful operation.
Nearly all characteristics of the consensus layer
Within the next two years, Ethereum’s consensus layer algorithm will undergo significant upgrades, including validator stake participation thresholds, punishment and reward mechanisms, distributed validation technology (DVT), and light client validation protocols, among others.
Slot block time
As the time duration of slot blocks compresses further, relying directly on block.slot as a timestamp proxy will become completely ineffective.
Distributed block building mechanism
With the advancement of mechanisms such as ePBS and FOCIL, the whole network's block building model will undergo profound restructuring.
Transaction serialization format
The old historical transaction format may gradually be phased out in the future; in a few years, transactions based on SSZ serialization under EIP-8141 will likely become the only supported standard transaction format on Ethereum's mainnet.
It is particularly worth mentioning that the EVM as a whole is not listed in the mutable list. Even if Ethereum introduces an entirely new native instruction set (such as RISC-V) in the future, it can still ensure that existing bytecode logic is executed consistently through a compatibility layer.
Among these, the only aspect that will truly undergo dynamic adjustments remains the gas charging expenses of various operation codes.
This list is merely a preliminary summary after several hours of organization. Moving forward, the core developer team should collaborate to create a more detailed evolution black and white list, clearly delineating mutable zones from backward compatibility cornerstones.
For the vast majority of standard applications (such as Uniswap-like DEX), they can naturally be immune from the overwhelming majority of upgrade impacts. But for immutable contracts and complex financial applications, the entire industry must still establish defensive rule lines early.
免责声明:本文章仅代表作者个人观点,不代表本平台的立场和观点。本文章仅供信息分享,不构成对任何人的任何投资建议。用户与作者之间的任何争议,与本平台无关。如网页中刊载的文章或图片涉及侵权,请提供相关的权利证明和身份证明发送邮件到[email protected],本平台相关工作人员将会进行核查。