TechFlow Logo
Login/ Sign up
ETH Gas
Gwei
Fear
gas
Vitalik's In-Depth Article: Why EIP-8037 is the Essential Path for Ethereum's Secure Scaling?

Vitalik's In-Depth Article: Why EIP-8037 is the Essential Path for Ethereum's Secure Scaling?

2026.11.16
Share
Ethereum short-term scaling must decouple execution from state growth. EIP-8037 reprices state creation through a state gas pool mechanism, paving the way for a significant increase in the gas cap while safeguarding decentralization and node security.

Author: Vitalik Buterin

Translated by: TechFlow

TechFlow Preview: The core contradiction in Ethereum scalability lies in resource heterogeneity: computational execution and network transmission can scale efficiently through hardware iteration and parallelization, while the unrestrained expansion of global state volume is strictly constrained by hardware storage and synchronization bottlenecks.

As the core proposal for the Glamsterdam upgrade, EIP-8037 introduces a state Gas reservoir mechanism, significantly repricing the cost of creating new states, and for the first time decouples execution scaling from state inflation at the protocol level. Although this breaks some outdated application assumptions hardcoded with Gas, it remains the only viable engineering path for secure Ethereum scaling.

Special thanks to Binji, Lukasz Rozmej, and other colleagues for their feedback and review of this article.

The core objective of EIP-8037 is to decouple Ethereum's scalability boundaries: allowing a significant increase in easily scalable execution computations while strictly limiting the growth of hard-to-scale state volume. This is the most pragmatic solution to balance scalability capabilities and system security in the short term.

This article will focus on exploring the following five topics:

· Articulate the core logic behind advancing EIP-8037;

· Demonstrate why mechanisms similar to EIP-8037 are an inevitable path for secure Ethereum scaling;

· Discuss mitigation strategies for potential compatibility issues arising from EIP-8037 (including current progress, potential solutions, and the fundamental constraints behind them);

· Analyze the communication gap between the core layer and the application layer, and reflect on why expected mismatches in future EVM rule evolution arise;

· Provide a survival guide for developers writing immutable contracts and applications, explaining how to maintain contract security throughout subsequent roadmap iterations.

Background: Capacity Limits of Different Resource Types in Ethereum

Over the past decade, the two most widely recognized core objectives of the Ethereum community can be summarized as: maintaining decentralization and security, and achieving large-scale scalability.

To achieve scaling without sacrificing decentralization, we must first clarify the capacity limits of underlying resources in Ethereum: if we simply bluntly raise the Gas limit without any other improvements, where exactly will the system break?

Below are the main resource load statuses currently carried by the Ethereum network:

Figure: Current operational load baselines for major Ethereum resource dimensions

If we follow a naive linear extrapolation, increasing the Gas limit directly by 10x would cause all the above values to scale up by exactly 10x.

An increase of 10x for the first item (average validation time) remains within acceptable limits (though it will impose some pressure on staking nodes running on personal laptops), but scaling the remaining three items by 10x would be a disaster the network could absolutely not tolerate. Apart from Blobs, any scaling on the Ethereum execution layer would directly hit these three red lines:

· Scaling execution computation: directly increases worst-case block validation latency;

· Scaling Calldata: directly increases worst-case network-wide broadcast transmission time;

· Scaling state (especially creating new states): directly causes explosive state volume growth. A larger state not only raises disk capacity and performance thresholds, significantly lengthening initial sync time for full nodes, but also undermines the network's deterministic guarantee for full state synchronization success, and slows down all state I/O reads and writes during daily execution.

Changes Brought by Other Glamsterdam Proposals

Before discussing EIP-8037, let's examine the improvements brought by other core proposals in the Glamsterdam upgrade:

· EIP-7976: Raises the baseline cost of Calldata from the previous (non-zero byte: 40, zero byte: 10) uniformly to 64 per byte, effectively compressing the maximum Calldata size per block;

· EIP-7928: Introduces Block-level Access Lists (BAL), supporting parallelized validation, which significantly shortens validation time and improves sync speed;

· EIP-8038: Increases the Gas cost for state I/O operations;

· EIP-7732 (ePBS): Through a pipelining processing mechanism, expands the safe validation time window for a single block from approximately 2 seconds to about half a Slot (i.e., 6 seconds).

Let's incorporate these proposals into our considerations and reassess the system load performance when the Gas limit is increased 10x:

Figure: Stress test simulation of 10x Gas limit after implementing Glamsterdam optimizations

From the data above, it is clear that there are few major bottlenecks at the computational execution level. Calldata transmission is also nearing compliance, and subsequent EIP-8279 and EIP-8131 in the Hegota upgrade will further reduce the worst-case volume by approximately 1.6x.

Combined with planned P2P transmission optimizations, the network can easily gain more bandwidth headroom; if further expansion is needed, EIP-8288 will also support stripping signatures and proofs out of Calldata.

Therefore, with the boost from the Glamsterdam and Hegota upgrades, Ethereum has fully capable computing and networking layers to withstand 10x or even higher increases in the Gas limit.

The only fatal bottleneck remaining in the entire system is state volume.

When Resource Constraints Are Asymmetric: The Logic of Repricing

For nearly a decade, Ethereum has followed a simple and clear iron rule: the Gas pricing for any given resource must accurately reflect its actual physical burden on the underlying network. If resource A imposes a burden on the network that is 10 times that of resource B, then the Gas cost for either A or B must be dynamically adjusted so that A's cost reaches 10 times that of B.

The most classic historical example is the SLOAD opcode: initially requiring only 50 Gas, it was gradually repriced to 200 due to real hardware bottlenecks in state reads/writes, later rising to 800, and finally adjusted to the current 2100.

Facing the severe asymmetry in resource capacity described above, EIP-8037 does exactly the same thing: significantly increasing the cost of creating new states, whether adding new storage slots, writing new code, or creating new accounts.

The following is a comparison of the recommended cost adjustments by EIP-8037 (converted to final total overhead):

Figure: EIP-8037 repricing plan for state creation operations

It should be noted that state Gas is not subject to the 16.7M execution Gas limit per transaction, so deploying a full-size 24 KiB contract can still execute normally.

Additionally, EIP-8037 introduces brand-new logic to eliminate cost-avoidance loopholes. For example, under current rules, creating a new account via a standard ETH transfer doesn't even require paying the 25,000 NEWACCOUNT overhead; however, after EIP-8037 takes effect, creating a new account through any path will mandatorily require paying the full 183,600 state Gas without exception.

More profoundly, EIP-8037's design allows these state overheads to be further adjusted upward over time. The core parameter determining this cost, CPSB, is initially set to 1530 and will be synchronously raised alongside Gas limit increases.

This design reflects a consensus among core developers: computational and data transmission scaling will become increasingly easier, but the physical limits of state storage are very difficult to overcome. Before introducing a completely new state paradigm, every byte of storage occupancy is a tangible burden, and states cannot be easily sharded because any block proposer or replay node must possess the complete state data to function properly.

Trade-offs of Alternative Solutions

Faced with the dilemma of state inflation, apart from repricing, there are actually only four alternative choices in engineering practice:

· Never scale Ethereum at all;

· Calmly accept the centralization of nodes caused by massive state;

· Avoid increasing the cost of state creation, instead significantly lowering the costs of all other operations;

· Introduce a dedicated mechanism to detach this additional Gas overhead from the execution path, allowing users to complete payment along an independent dimension.

The first choice obviously severely contradicts the wishes of the vast majority of Ethereum community members; the second choice directly undermines Ethereum's foundational security commitment.

The third option was thoroughly discussed but ultimately rejected, as its disruptive impact would be far more severe than raising prices: drastically reducing Gas across all dimensions except state creation would trigger unquantifiable chain reactions and unknown risks.

Furthermore, to achieve a scaling factor of 3x or more, the costs of fundamental opcodes like ADD and PUSH would be forced below 1 Gas, compelling Ethereum to introduce an extremely complex milli-Gas mechanism.

Therefore, the only remaining way out is the fourth choice: which is exactly the breakthrough strategy of EIP-8037, although it can currently only resolve a portion of the derived issues.

Design and Operation of the Reservoir Mechanism

EIP-8037 is a crucial step for Ethereum towards "multi-dimensional Gas". Under this mechanism, a single transaction can simultaneously specify multiple Gas limit dimensions: one portion used for execution Gas, and another portion designated as a state Gas reservoir.

By default, the portion of a transaction within the 16.7M execution limit is entirely allocated as execution Gas, while the excess automatically flows into the reservoir (future EIP-8141 frame transactions will allow users to define these two values more explicitly, eliminating the need to artificially inflate the transaction Gas limit to fund it).

Any operation involving state creation must first deduct fees from the state Gas reservoir; only after the reservoir is depleted will it revert and deduct regular execution Gas. Importantly, the state Gas reservoir is completely transparent to subcalls: a parent call can strictly limit the execution Gas allocated to a subcall, but cannot cut off the subcall's access to the state Gas reservoir.

This design philosophy is highly similar to the access list mechanism introduced by EIP-2930 back then: when EIP-2929 increased storage read costs and broke some legacy contracts, EIP-2930 allowed users to predeclare and pay for read overhead in the transaction header, thereby restoring cheap reads within the execution path.

The reservoir mechanism successfully resolves the following core challenges:

· Allows a single large contract deployment to consume Gas far exceeding the 16.7M execution limit;

· Allows certain external calls containing hardcoded fixed Gas limits to run normally, as long as the entire transaction is wrapped in a higher Gas transaction equipped with a reservoir;

· Allows parent calls to invoke child contracts using patterns similar to gasleft - N, ensuring that even if a subcall exhausts Gas and reverts, the parent call retains sufficient N Gas to complete necessary post-state cleanup.

In the long run, this mechanism allows Ethereum to calculate block-wide limits, target capacities, and even dynamic Gas pricing separately for different resource dimensions (state creation, regular execution, state I/O), providing a minimal-cost engineering solution to address the architectural challenges of multi-dimensional Gas.

Edge Cases Not Yet Resolved by the Reservoir

However, the reservoir is not a silver bullet, and several categories of compatibility issues persist:

· Constructing oversized Gas transactions is cumbersome: before EIP-8141 officially takes effect, requiring frontends to construct transactions exceeding 16.7M Gas feels quite bloated, demanding substantial frontend refactoring from app developers;

· Hardcoded configurations cannot be upgraded: core applications like cross-chain bridges have their transaction construction or call parameters hardcoded into modules that are difficult to upgrade;

· Reservoir injection is purely optional: taking the OP Stack bridge mechanism as an example, its underlying layer contains a hardcoded 40,000 Gas limit. Malicious actors could intentionally send a withdrawal transaction without a reservoir, deliberately exhausting call Gas to cause failed withdrawals, while external logic might mistakenly mark it as completed;

· Instant refunds disrupt Gas metering: the proposal switches to an instant refund mechanism rather than settling at the end of the transaction, causing the remaining Gas value returned by the GAS opcode to potentially jump abnormally high;

· EIP-8038 lacks reservoir protection: EIP-8038 raises the SSTORE cost from 5,000 to 12,100 without configuring a reservoir, directly breaking a tiny minority of legacy apps;

· Hinders account abstraction: after using the reservoir, the GAS opcode can no longer accurately track the total energy consumed by subcalls, making it difficult for ERC-4337 abstract accounts to smoothly utilize reservoir Gas.

Addressing these pain points, the community has explored various protocol-layer remedial measures: such as restoring end-of-transaction refund settlement, canceling EIP-8038 at the cost of narrowing scalability space by 2.4x, and adding a reservoir for state I/O.

Other concepts include early implementation of the EIP-8141 foundational framework, distinguishing empty slot values from zero values, enforcing full-frame rollback on subcall overruns, or exempting legacy contracts (EIP-8488), among others.

However, objectively evaluated, each of the aforementioned remedial measures constitutes a major deep-tier modification that easily invites more unforeseen vulnerabilities. The only relatively mild instant refund adjustment can only salvage a minuscule fraction of affected apps; with the Glamsterdam upgrade entering late-stage testing, any protocol-layer changes would drastically escalate operational and deployment risks.

How Should Application Developers Respond Today?

Ethereum's scaling is essentially an asymmetric resource game. Pure computational execution scales most easily, followed by state I/O and Calldata, while state volume expansion is the most stringent.

To implement precise differential scaling for different resources, the system must dynamically reset their relative Gas costs; and under current realistic engineering boundaries, EIP-8037 and EIP-8038 represent compromise solutions already very close to the optimal answer.

The core developer team assesses that forcefully slapping fragile patches onto the protocol layer not only carries extremely high development costs but also introduces unknown systemic risks, severely slowing down the overall pace of quantum-resistant upgrades and mainnet scaling.

Therefore, a more pragmatic path focuses primary efforts on application-layer coordination: fully assisting the vast developer community to ensure all applications and smart contracts affected by EIP-8037 and EIP-8038 complete adaptation and fixes before the Glamsterdam upgrade officially launches on mainnet.

This includes:

· Actively delaying the Glamsterdam launch window (already executed);

· Comprehensively and transparently clarifying these potential technical impacts (multiple public seminars and conference calls have been held);

· Allocating dedicated ecosystem resources to assist in identifying affected projects and driving patches (work is currently underway).

Survival Rules for Immutable Contracts Facing the Future

Facing this turmoil, many developers have raised a perfectly reasonable and profound question: Ethereum's core value lies precisely in empowering users with strongly secured decentralized applications; writing immutable contracts without admin upgrade private keys is meant to fulfill this promise. If the next hard fork could arbitrarily break established rules, how exactly should developers write safe and enduring smart contracts moving forward?

Regarding this event, the answer boils down to one sentence: never assume Gas overhead rules are eternally fixed.

Within the early Ethereum core developer and security audit circles, this has always been an implicit foundational consensus. However, since 2021, this understanding has rarely been formally documented and reiterated, leaving many new-generation developers who joined in subsequent cycles unaware that it serves as a default foundational assumption across the core developer community when advancing EIP-8037.

Facing the future, we must formalize these implicit rules: reach a high degree of consensus across the ecosystem regarding which protocol-level features belong to mutable areas, and through widespread dissemination, make this common industry knowledge. Today, Ethereum's development roadmap (Strawmap) is highly clear and mature, allowing us to make relatively precise predictions about which features may undergo disruptive adjustments in the future.

Below is a personally compiled checklist of Ethereum features expected to change in the future:

Any Form of Gas Mechanism

When designing smart contracts, any specific Gas limit should be dynamically specified by the party that bears the loss due to an incorrectly set limit. In the vast majority of scenarios, applications are already naturally executing this principle: if transaction Gas is insufficient, the user sending the transaction suffers the loss, therefore the transaction Gas limit is entirely autonomously chosen and configured by the user's wallet.

Moving forward, dynamic specification must be extended to all processes, completely abandoning the practice of hardcoding any specific Gas values within contract code.

Developers are also advised not to assume subcalls will always run below total Gas: once EIP-8141 takes effect, this mechanism may be entirely removed to simplify the protocol, as its use cases can be implemented more elegantly within frames.

State Tree and Block Hash Structure

The current state tree will likely be restructured into a binary partitioned tree based on Keccak, and block structures along with transaction receipts will fully transition to Keccak-based SSZ serialization formats.

Mathematical Finite Fields Used for Blob Point Evaluation

The current system utilizes an approximately 253-bit inner field for BLS-12-381, which will likely migrate to a 128-bit binary finite field in the future.

Subsequent Evolution of Blob Data Structures

With the change in finite fields, the maximum size of a single Blob is expected to be standardized to exactly 131,072 bytes, potentially ushering in even more significant structural reorganizations later.

ECRECOVER Precompiled Contract

To ensure that accounts upgraded to quantum-resistant cryptography in the future won't suffer replay attacks due to historical offline pre-authorization vulnerabilities, ECRECOVER is expected to be transformed into a stateful operation.

Virtually All Consensus Layer Features

Within the next two years, the Ethereum consensus layer algorithm will undergo radical upgrades, including significant changes to validator staking requirements, penalty/reward mechanisms, Distributed Validator Technology (DVT), and light client verification protocols.

Block Production Time per Slot

As the time duration for block production per slot is further compressed, solutions directly relying on block.slot as a timestamp proxy will become completely invalid.

Distributed Block Construction Mechanisms

With the advancement of mechanisms like ePBS and FOCIL, the network-wide block construction model will undergo profound restructuring.

Transaction Serialization Format

Legacy historical transaction formats may be gradually phased out in the future; in a few years, SSZ-serialized EIP-8141 transactions will likely become the sole supported standard transaction format on the Ethereum mainnet.

Worth specifically noting is that the EVM as a whole is not listed as a mutable area. Even if Ethereum's underlying layer introduces an entirely new native instruction set (such as RISC-V) in the future, it can fully guarantee identical execution of existing bytecode logic through a compatibility layer.

Among these, the only things that will truly undergo dynamic adjustment remain the Gas billing overheads for various opcodes.

This checklist is merely an initial summary compiled over a few hours. The core developer team should subsequently collaborate to develop a more detailed black-and-white list of evolutions, clearly demarcating mutable areas and backward-compatibility bedrock.

The vast majority of standard applications (such as Uniswap-like DEXs) are naturally immune to most upgrade shocks. However, when facing immutable contracts and complex financial applications, the entire industry must still establish regulatory defenses as early as possible.

Join TechFlow official community to stay tuned

Add to Favorites
Share to Social Media