A delayed testnet fork shows that immutable bytecode can still lose its assumptions when the protocol changes the price and accounting of state.
Ethereum’s Glamsterdam upgrade is forcing the network to answer a difficult question: what does immutability mean when contract code stays fixed but the execution environment changes around it?
The question became operational after security reviews found that two proposed gas reforms, EIP 8037 and EIP 8038, could disrupt deployed applications that rely on assumptions about gas prices, refunds, call failures and the amount of work possible after an internal call runs out of gas. Ethereum core developers postponed the Hoodi testnet activation in October. A broader assessment then identified hundreds of findings across bridges, wallets, exchanges, governance systems, oracles, staking protocols and offchain services. Most appear fixable. Some require contract upgrades or migration. A few involve contracts that are difficult or impossible to change.
This is not evidence that Ethereum is failing to scale. It is evidence that scaling a programmable settlement system requires more than increasing capacity. The protocol must price computation and state accurately enough to protect nodes, while preserving enough behavioral continuity for applications that were designed under older rules. Those goals can conflict.
Gas is often described as a fee mechanism. That description is incomplete. Gas is also a resource accounting system and, for many contracts, an implicit control surface. Developers use gas limits to bound callbacks, reserve enough execution for cleanup, infer whether a subcall failed, constrain relayers and price services. If the protocol changes both the price of operations and the way gas is returned across call frames, a contract can behave differently without changing a single byte.
Glamsterdam has therefore become an immutability test. The outcome will help define how Ethereum balances sustainable state growth, application compatibility, security review and credible protocol governance.
Why Ethereum wants to reprice state
Ethereum’s state is the persistent information that nodes must maintain to validate the chain. It includes accounts, contract code and storage slots. Unlike transient computation, state remains relevant after a transaction ends. A contract deployment or new storage slot can create a lasting burden for every validating node and for future synchronization, proof construction and database access.
The current gas schedule does not price every form of state creation consistently. The official EIP 8037 specification explains that contract bytecode, storage slots and accounts can impose different gas costs for similar quantities of new persistent data. The proposal introduces a cost per state byte and targets an average state growth rate of roughly 120 gibibytes per year at a reference block gas limit of 150 million.
The economic objective is understandable. Ethereum wants to raise throughput, but higher gas limits can accelerate state growth. If state creation remains too cheap relative to the burden it places on nodes, capacity today can reduce decentralization tomorrow. Larger databases increase hardware requirements, make node operation more demanding and enlarge the surface for denial of service attacks that exploit underpriced operations.
EIP 8037 would sharply increase the cost of creating new state. The specification estimates that a new account would cost around seven times more, a new storage slot around five times more and deployment of a 24 kilobyte contract around eight times more than under the previous schedule. These multiples sound severe, but the proposal separates state gas from ordinary execution gas and assumes a low base fee in its illustrative cost estimates. The goal is not simply to make applications expensive. It is to align payment with the long term burden each action creates.
EIP 8038 addresses access to existing state. As Ethereum’s database grows, operations that read accounts, storage and code can require more work from clients. The proposal raises selected access costs, introduces explicit surcharges for writes and separates access, modification and creation into clearer components.
These reforms are part of a larger Glamsterdam plan that includes block level access lists, proposer and builder changes, and a higher capacity path. Repricing is meant to remove hidden subsidies before the network expands. Without it, a larger gas limit could amplify the most expensive state operations faster than clients can safely absorb them.
The policy problem is therefore real. Ethereum cannot promise indefinitely that yesterday’s gas schedule will remain efficient as state and throughput grow. Yet a correct price for future transactions can still break assumptions embedded in past contracts.
The reservoir changes more than prices
The most consequential part of EIP 8037 is not the higher number attached to a storage slot. It is the introduction of a separate state gas reservoir.
Under the proposed model, a transaction can carry resources for execution and for state creation. State charges may draw from a reservoir that is not reflected in the ordinary GAS opcode in the same way as existing accounting. Gas available to a frame can therefore move in patterns that older contracts did not expect. A reverting call may return state gas. Gas left can increase across a call. A caller may retain enough resources after a failed subcall to execute cleanup or write a failure state that used to be impossible.
The Ethereum Foundation’s November 6 call for review made the concern explicit. Testing identified deployed projects that depend on invariants affected by EIP 8037 and EIP 8038. The Foundation asked developers and auditors to inspect both onchain and offchain systems and report affected cases.
The official gas invariants repository organizes the issue into eight assumptions. Some are simple price assumptions. Others concern execution and accounting semantics.
One assumption is that if a subcall runs out of gas, the entire transaction cannot continue far enough to record a permanent result. Under the proposed reservoir model, the caller may still have state gas available. Code that marks a task as completed after a failed call could therefore finalize an incomplete operation.
A second assumption concerns storage that is created and cleared in the same transaction. Immediate restoration of state gas can leave more resources available than existing contracts anticipate, especially around locks or temporary flags.
A third concerns reverted calls. If a call returns state gas after reverting, the caller may have more capacity than code based on the old schedule expects. Contracts that infer the reason for failure from empty return data or gas behavior can reach the wrong branch.
The fourth is the most common: a fixed gas amount will always be enough for a known action. New storage, accounts and contracts become several times more expensive under the proposed schedule. Hard coded callback limits, relayer budgets, signed gas allowances and operational settings may no longer cover the same work.
The fifth assumption is that gas left only declines. Applications sometimes calculate work by subtracting one gasleft() reading from another. If gas can be restored across a frame or hidden in a reservoir, that calculation can become negative or economically misleading.
The sixth concerns the fraction of gas retained by a caller when forwarding resources to a subcall. Under the old price structure, the retained amount might be too small to do meaningful work. Under the new structure, it can sometimes be enough to finish a path and record a result after the subcall fails.
The seventh concerns reserves and stipends. A fixed reserve sized for an old storage write may not support the same cleanup under new prices. A nonce, authorization or task status could be consumed before the intended external action completes.
The eighth concerns EIP 7702 delegations. A mined transaction may not prove that a delegation was successfully applied if the operation runs out of gas and is rolled back. Offchain software that treats inclusion as sufficient confirmation can misrepresent account state, while a reusable signed delegation may remain exposed.
These are not eight versions of the same bug. They show that gas performs several roles at once: pricing, resource isolation, failure signaling, execution control and offchain confirmation. Changing the accounting model can touch every role.
The audit findings are broad but not uniform
The public ChainSecurity impact assessment combined code review, a year of mainnet transaction traces and replay under candidate rules. It reported 200 findings: three High, 30 Medium and 167 Low. None was rated Critical.
That distribution requires careful interpretation. It does not justify panic. Most findings were linked to fixed gas budgets and could be addressed through configuration changes. The report says 24 findings require a contract upgrade or migration. The affected system types include bridges, messaging systems, wallets, exchanges, governance, oracles, staking protocols and supporting offchain services.
The breadth matters because these systems connect to one another. A relayer may submit a message to a bridge, which invokes a contract, updates storage and emits data consumed by an indexer. If any component assumes a fixed gas budget or interprets a mined transaction as proof of success, the fault can move across the stack. The contract may be correct in isolation while the operating system around it reaches the wrong conclusion.
The absence of a Critical finding is encouraging, but it is not a completeness guarantee. Auditors cannot review every deployed contract, every private codebase or every offchain service. Immutable contracts may have no public source. Upgradeable systems may have complex authority paths. Some failures depend on transaction values chosen by an attacker or on gas ranges that ordinary tests do not explore.
This is why the Hoodi delay was appropriate. The official postponement notice removed the planned activation and the associated gas limit increase while teams investigated the interaction with mainnet contracts. The change did not revert testnet history and did not schedule mainnet. It created time for evidence.
Delay has a cost. Client teams maintain branches and test configurations. Application teams face uncertainty. Later upgrades compete for engineering attention. But a public testnet exists precisely to reveal assumptions before mainnet makes them irreversible. A delayed rehearsal is cheaper than an emergency response after activation.
Immutability has more than one layer
The ordinary meaning of an immutable smart contract is that no administrator can replace its bytecode or edit its storage rules at will. That property remains valuable. It limits discretionary power and allows users to inspect a program before interacting.
Protocol execution is a different layer. Every contract depends on the Ethereum Virtual Machine, opcode semantics, gas schedule, transaction envelope and consensus rules. A contract is immutable inside a mutable platform.
That dependence is not a defect unique to Ethereum. Every software system relies on lower layers. A binary depends on an operating system. A web service depends on network protocols. A token depends on a ledger. The difference is that smart contracts often hold assets and are intentionally designed without an upgrade path. Their inability to change is presented as a security feature, so a protocol change that alters their effective behavior creates a governance tension.
The Optimism upgrade authority analysis provides a useful comparison. A rollup can make authority explicit through security councils, governance procedures and exit paths. An immutable Ethereum contract may have no comparable escape route. If it relies on a gas invariant that disappears, users cannot vote the bytecode into compliance unless the system already contains migration or upgrade machinery.
This does not mean Ethereum must freeze its gas schedule forever. A permanent subsidy for underpriced state would transfer costs from application developers to node operators and future users. It could also reduce the credible capacity of the network. The stronger conclusion is that immutability claims need to specify their layer.
Bytecode immutability means the code cannot be replaced. Storage immutability means governance cannot alter selected state. Economic immutability would mean the relative cost of operations remains stable. Semantic immutability would mean execution outcomes remain equivalent across protocol upgrades. Ethereum provides the first in many contracts and protects the second according to contract design. It has never guaranteed the third or fourth absolutely.
Glamsterdam shows why users should not treat those categories as interchangeable.
Fixed gas limits are hidden governance
Many affected systems appear to rely on fixed gas amounts rather than intentionally changing semantics. That may sound like a minor engineering mistake. In reality, a fixed gas limit is a governance decision embedded in code or operations.
A bridge that forwards a fixed budget to a destination assumes the called function will remain inside that envelope. A wallet that reserves a fixed amount for cleanup assumes storage prices will remain within a band. A relayer that signs a maximum gas allowance assumes the transaction can finish under future schedules. A governance executor that sends a limited callback assumes failure will be visible and recoverable.
Those assumptions allocate risk. A small limit can protect the caller from unbounded work but expose the callee to future repricing. An adjustable limit improves compatibility but gives an administrator or relayer more control. Automatic gas estimation can adapt, but it depends on clients and RPC providers implementing the new rules correctly.
The earlier Block2Learn analysis of crypto transaction intent verification makes the same broader point. A valid signature proves authorization of bytes. It does not prove that the user understood the economic or operational outcome. Likewise, immutable bytecode proves that code has not changed. It does not prove that the surrounding execution environment produces the same effect.
Security language should describe the whole control path. For Glamsterdam, that path includes the contract, any upgrade authority, gas configuration, relayers, client estimation, offchain confirmation and recovery behavior.
Repair options create different tradeoffs
Most affected applications have several possible responses.
The simplest is to increase configurable gas limits. This works when the budget lives in an administrator setting, relayer configuration or offchain service. It preserves the contract logic but may increase user cost and requires careful bounds.
A second response is to replace fixed limits with estimation plus a margin. This adapts to the new schedule, but estimation can differ across providers and may fail on paths that depend on state or adversarial input. A margin should be justified by testing, not chosen as an arbitrary multiplier.
A third response is to change failure handling. Contracts can revert when a required subcall fails, preserve retryability, verify return values and avoid consuming a nonce before success is established. These patterns reduce dependence on gas behavior. They may require an upgrade or migration if the existing contract is already deployed.
A fourth response is to use transient storage for temporary locks and flags. That can avoid creating and clearing persistent state during one transaction. It changes implementation and requires compatibility with the intended environment.
A fifth response is to revise the EIP specifications. Developers have discussed alternatives that restore gas later, protect selected invariants or reduce disruption. Any specification change can solve one class of problems while creating another. It also requires new client implementation, tests, audits and deployment coordination.
The latest public All Core Developers execution discussion reached rough agreement to continue with the current specification unless a viable alternative emerges. Application outreach indicated that many affected projects could be ready by mid January. A Hoodi fork in the week of December 14 was discussed as a candidate, subject to a later decision. These are planning signals, not a confirmed mainnet date.
The sixth response is to accept limited breakage. Protocols sometimes decide that maintaining every historical assumption would impose excessive cost on the network. That decision should be explicit, supported by impact analysis and paired with a migration plan. Silent breakage is governance by surprise.
The process is becoming part of the upgrade
Glamsterdam has exposed a process gap as well as a technical issue. Gas invariants were not captured early enough as first class compatibility properties. Some risks were known, but structured outreach and replay identified the breadth close to a planned testnet activation.
Ethereum is responding by documenting invariants, building test corpora and connecting protocol teams more directly with application developers and auditors. That is a constructive outcome. A mature upgrade process should test not only whether clients agree on the new rules, but whether important applications remain safe under them.
This does not require the protocol to promise perfect compatibility. It requires a repeatable method for identifying intentional breaks, estimating affected value, contacting operators, testing mitigations and publishing the decision.
The distinction matters for decentralized governance. Core developers can coordinate software releases, but they do not control every application. Application teams can upgrade their own systems, but they do not set consensus rules. Users depend on both groups. A credible process must make the boundary visible.
The Block2Learn article on Europe’s tokenised securities standards reaches a similar conclusion in a different environment. Shared infrastructure succeeds when technical standards and authority boundaries are explicit. Ethereum’s public network replaces legal coordination with open source software and social consensus, but it cannot eliminate the need to define responsibility.
Market implications are second order
Glamsterdam is not a simple bullish or bearish catalyst for Ether. The immediate market effect is smaller than the engineering significance.
A successful repricing can make higher gas limits more sustainable, reduce denial of service exposure and better align fees with node costs. Those benefits support Ethereum’s long term capacity and credibility. They can also improve the foundation for layer 2 settlement and application growth.
The near term costs include delayed activation, migration work, higher state creation fees and uncertainty for applications with fixed gas assumptions. Some contract deployments and storage heavy actions become more expensive. Teams may move selected activity to rollups or redesign state use. Those changes can improve efficiency, but they also introduce development cost.
Ether value does not follow mechanically from one gas parameter. Lower or higher transaction fees can affect burn, demand and activity in different directions. A safer, more scalable network may attract usage even if individual state operations cost more. A delayed upgrade may reduce short term expectations without changing the long term roadmap.
The stronger market signal is governance quality. Investors and builders should ask whether Ethereum detects compatibility risks before mainnet, publishes evidence, coordinates fixes and avoids both reckless speed and indefinite paralysis. The delay itself is not failure. The quality of the decision that follows will be the test.
The Ethereum post quantum roadmap offers another comparison. Long term resilience requires cryptographic agility, staged testing and coordination across wallets, validators and applications. Glamsterdam is a nearer version of the same problem. A protocol upgrade becomes credible when the surrounding ecosystem can absorb it.
Three scenarios
Current specifications proceed after remediation
In the constructive base case, affected projects raise limits, upgrade contracts or migrate before Hoodi and mainnet. Client estimation handles the two dimensional model correctly. The testnet exposes no new systemic class of failure. Ethereum keeps most of the proposed repricing and preserves the scaling benefits.
This outcome would demonstrate that the application layer can adapt without forcing the protocol to preserve every historical gas assumption. It would also validate the delay as a successful safety intervention.
Targeted specification changes protect key invariants
In a compromise scenario, developers identify a small set of accounting changes that materially reduce breakage without undermining state pricing. Client teams implement and audit the revision, delaying activation further.
This path may produce a cleaner compatibility result, but it carries implementation risk. A patch introduced late in the cycle can create new edge cases. Success depends on a narrow change, strong tests and clear documentation of which invariants remain intentionally different.
Hidden dependencies force another delay
In the adverse scenario, new contracts or offchain systems fail during Hoodi testing, or supposedly simple configuration fixes prove insufficient. The upgrade is postponed again, application confidence weakens and later roadmap work competes for attention.
Another delay would not automatically threaten Ethereum. It would raise the cost of the upgrade and reveal that the compatibility surface was larger than expected. The worst outcome would be activation under unresolved uncertainty followed by emergency intervention on mainnet.
What to monitor
The first signal is the formal Hoodi schedule. A candidate week is not an activation commitment. The exact epoch, client releases and go or no go decision matter.
The second is the final status of EIP 8037 and EIP 8038. Review the specification rather than relying on earlier summaries, because reservoir behavior and refunds are central to compatibility.
The third is application remediation. Configurable gas changes are easier than immutable contract migrations. The mix of fixes will show how much risk remains.
The fourth is client estimation. Wallets and RPC providers must return gas limits that cover execution and state creation. Underestimation can turn a sound contract into a failed user transaction.
The fifth is offchain confirmation logic. Indexers, relayers and wallets should verify resulting state rather than treating inclusion as proof that every internal action succeeded.
The sixth is additional audit coverage. The public assessment was broad, not exhaustive. New findings should be evaluated by severity and reach, not counted without context.
The seventh is the mainnet date. A schedule should follow stable testnet behavior, not replace it.
The Block2Learn view
Glamsterdam is exposing a hidden truth about programmable blockchains. Immutability is not a single property. A contract can preserve its bytecode while losing the economic and execution assumptions that made the bytecode safe.
Ethereum has a legitimate reason to reprice state. Persistent data imposes real costs on every node, and higher throughput cannot be sustainable if those costs remain underpriced. The protocol also has a responsibility to understand how repricing affects systems that users already trust with assets and permissions.
The correct standard is not zero change. It is explicit change. Developers should know which invariants are being altered, operators should have time to test, users should have a migration path where necessary, and core teams should publish the evidence behind their decision.
The Hoodi delay shows the safety process working. Whether it becomes a governance success depends on what happens next: a disciplined specification decision, verified remediation, stable client behavior and a testnet activation that produces evidence rather than pressure.
Readers who want to connect protocol engineering, application controls, governance and market structure can continue through the Block2Learn Learning Path.
Information is abundant. Structure is rare.
This article is provided solely for informational and educational purposes and does not constitute financial or investment advice, a recommendation, or an offer or solicitation to buy or sell any financial instrument or digital asset. See our Financial Disclaimer.
This article was generated with the support of AI and reviewed by the Editorial Team. For more information, see our Terms of Service.









