Ethereum Glamsterdam Upgrade Delayed ⚠️ Gas Security Risks12 min read2,461 words

Ethereum Glamsterdam Upgrade Delayed ⚠️ Gas Security Risks

Ethereum Glamsterdam upgrade delayed: gas changes raised Ethereum gas security risks on Hoodi. Learn what failed, impacts, and smart contract next steps.

Ethereum Glamsterdam upgradeEthereum gas securityHoodi testnet forksmart contract securityEthereum network upgrade
Ethereum Glamsterdam Upgrade Delayed ⚠️ Gas Security Risks

Ethereum Delays Glamsterdam Testnet Fork After Gas-Security Findings

Ethereum developers have paused the planned Glamsterdam hard fork on the Hoodi testnet after security researchers flagged a risk in how the upgrade changes gas accounting. This isn't just about transactions coming out cheaper or more expensive than expected. Some smart contracts depend on very specific failure behavior when an external call runs out of gas. With Glamsterdam's changes, those failures may not behave the way the contracts were written to expect.

ChainSecurity says it found 13 real-world examples and is contacting the affected teams through responsible disclosure. That doesn't mean all 13 contracts have already been exploited, and it certainly doesn't mean every Ethereum contract is vulnerable. It does mean developers have a compatibility issue to look into before the testnet change goes further.

Hoodi was scheduled to activate on Monday, but developers postponed it while they assess the risk. This article breaks down which gas-related behaviors are involved, why failure semantics matter, what the delay changes for Ethereum's upgrade process, and what contract teams should do next.

What happened to the Glamsterdam Hoodi fork

Ethereum developers postponed Glamsterdam's scheduled activation on Hoodi after ChainSecurity reported security impacts tied to the upgrade's gas changes. They made the call before the fork date, so the immediate step was to stop Hoodi from activating on schedule while developers and affected projects evaluate the findings.

ChainSecurity says it had already identified 13 real-world examples of contracts that could be impacted. The firm says it's following responsible disclosure, meaning it's reaching out to the relevant teams rather than publishing identifying details that could increase risk. The Ethereum Foundation is also working to determine how many contracts could be exposed.

For now, the reports point to a potential compatibility issue - not proof that anyone has attacked those contracts. That distinction matters. Unusual behavior under new network rules is reason enough to take a careful look, but it shouldn't be treated as a confirmed exploit without evidence.

The planned Hoodi fork was set to go live on Monday. Ethereum researcher Christine Kim advised node operators to either revert to an older software release that doesn't include the scheduled upgrade, or wait for their execution client team to issue a version that cancels the activation. Preston Van Loon, a developer on the Prysm consensus client, said Prysm would provide a release removing the upgrade from Hoodi's schedule that day.

Practically speaking, this kind of fork delay is both a coordination problem and a security review. Ethereum clients run independently, and a testnet upgrade can only be paused cleanly if operators have compatible versions and clear instructions for what to run. A scheduled protocol change also can't be treated like a typical application rollout where a team can simply roll back one server.

The immediate scope is Hoodi. The announcement doesn't say Glamsterdam is cancelled, that Ethereum mainnet is changing, or that users need to move funds. It's specifically that the upgrade can't proceed on the testnet timetable while gas-related behavior is investigated.

Why a gas change can affect contract security

Gas is the fee for computation and other operations on Ethereum. It also sets a real limit on how much work a transaction can do. Contracts and applications often make decisions based on those limits - especially around what happens when an external call doesn't have enough gas to finish.

Glamsterdam includes two proposals, EIP-8037 and EIP-8038, which change how gas is charged for creating and accessing stored data. The upgrade also adds a separate gas pool for creating new state. Those changes shift the economics of state-related work, but they can also change the assumptions contracts make about whether a call succeeds or fails.

The failure path is part of the contract's behavior

A contract's security isn't only about the "happy path." It also depends on what happens when calls fail - when a user supplies insufficient gas, or when another contract returns an error. In some designs, a failed external call is expected to revert the surrounding operation so it can be retried later.

ChainSecurity's analysis focuses on contracts that use gas checks or depend on an external call running out of gas to prevent a form of manipulation often described as insufficient gas griefing. In simplified terms, an attacker deliberately supplies too little gas so that an otherwise valid operation fails. If the contract treats that failure as permanent, the attacker may be able to stop a user or system from retrying.

This protection depends on a specific relationship between available gas, the work the external call performs, and how the contract handles failure. If a protocol upgrade changes that relationship, deployed code can behave differently even without changing a single line.

ChainSecurity says that under Glamsterdam, gas can be refilled or returned to a contract after a failed call, and repricing can also change how much gas a call needs. In its assessment, those effects could mean that a failure path that previously reverted may instead complete. The concern isn't that every failing call will become a success. The concern is that some existing contract logic may no longer distinguish outcomes the way its authors intended.

Why this can create a persistent problem

The risk is bigger when a contract stores the result of a failed operation. For instance, a system might mark a request as completed, rejected, or no longer eligible. If the contract writes that state in situations where it previously would have fully reverted, a user may lose the ability to retry through the expected normal flow.

That's why gas accounting is a security and compatibility issue, not just a transaction-pricing detail. Smart contracts run under the network's execution rules. A protocol change can alter those rules without changing application code, so upgrade testing needs to cover deployed contract behavior as well as the performance of Ethereum clients.

The 13 examples give teams a reason to audit their own code, but they're not the same thing as a complete exposure list. The Ethereum Foundation was still assessing the broader impact at the time of reporting. Teams should therefore check their own assumptions rather than assume safety because they didn't appear in a public list.

For background on Ethereum's transaction costs and execution model, see the Ethereum gas documentation. The key point is straightforward: contract logic that depends on gas behavior should be tested against the protocol rules that will actually be active after an upgrade.

What the delay means for Ethereum's upgrade path

Glamsterdam had already activated on Sepolia, another Ethereum test network, on October 6. Based on the reported upgrade details, Sepolia began producing blocks with a gas limit close to 200 million - more than three times the roughly 60 million limit cited for mainnet. Sepolia is also being used to test other parts of the upgrade, including block-level access lists and changes to block construction.

Those pieces are separate from the gas-security concern, but they're a reminder that upgrades should be reviewed as a set of interacting changes. Block-level access lists are intended to help computers check transactions in parallel. Glamsterdam also shifts the auction that determines how blocks get assembled in Ethereum protocol rules. Each change has its own goals and implementation work, but the hard part is validating how they behave together with real contracts and client software.

A successful activation on one testnet doesn't prove that every relevant risk has been identified. Testnets differ in usage patterns, contract inventories, and how they're operated. Security issues typically appear when researchers look at a particular interaction between a protocol rule and application code. Here, ChainSecurity reported that gas behavior could affect contracts that rely on specific failure semantics.

Developers had planned to ship Glamsterdam on mainnet by the end of 2026, ahead of Hegotá - the next planned upgrade, expected in 2027 and potentially including native privacy features. Those are roadmap intentions, not commitments. As reported, no new date was set for Hoodi after the postponement.

So the mainnet target should be read as conditional on further testing and remediation. Moving dates costs real time for client teams, infrastructure providers, application roadmaps, and users waiting for protocol improvements. But pushing forward while the contract risk is still not fully understood would likely create a bigger operational headache. A delay is useful when it leads to a better-informed decision; it isn't a substitute for actually fixing the underlying issue.

For context, see ChainSecurity's analysis and the original report on the Hoodi delay. The biggest unanswered questions are how many contracts share the affected assumptions, what code or protocol adjustments are needed, and when a revised Hoodi activation can be tested safely.

What developers and node operators should do

What you should do depends on your role. Contract teams need to examine how applications behave. Node operators need to follow Hoodi instructions from their execution and consensus client teams. Mainnet users should avoid jumping to conclusions the announcement doesn't support: the action is about Hoodi's testnet schedule, and there's no stated requirement for users to move assets or change wallets.

For smart-contract teams

Start by reviewing external calls and the state changes that follow them. Look for code that assumes a call will run out of gas, treats failure as a permanent outcome, or depends on a revert to keep an operation retryable. Also pay attention to checks that compare gas remaining before and after an external call.

Then test the failure cases directly. If you only test the "successful" execution path, you won't answer the question that matters here. Include scenarios where the caller provides insufficient gas, the external call fails, gas is returned or accounted for differently, and the contract tries again. Confirm whether the whole transaction reverts or whether persistent state gets written before control returns.

A sensible review sequence is:

  1. Identify external calls and low-level call patterns.
  2. Trace every failure branch, including state changes and emitted events.
  3. Confirm whether a failed operation can be retried without special privileges.
  4. Test against the updated execution rules and the relevant client releases when they're available.
  5. If you find a plausible issue, contact your security reviewer or use the disclosure channel you rely on.

Don't patch just because code looks similar to something ChainSecurity reported. A rushed change can introduce a different failure mode - especially in contracts where external calls and state updates are tightly coupled. Reproduce the behavior, document the invariant you expect, and make the smallest change that restores it.

For node operators and infrastructure teams

Hoodi operators should follow instructions from their execution-client and consensus-client teams. The reported guidance so far is to use an older release without the upgrade scheduled, or wait for a new version that removes the Hoodi activation. Operators should confirm the exact release and network configuration rather than assuming all clients handle cancellation the same way.

This is also a reminder to treat testnet operations like production work. Testnets may not carry the same economic stakes as mainnet, but they're still part of the release process for software that can later touch valuable systems. Monitoring client announcements, coordinating upgrades, and checking the active fork schedule are operational responsibilities - not just administrative details.

For product teams and users

If you build on Ethereum, ask your contract and infrastructure providers whether they've assessed the findings. That's more useful than assuming everything's fine because the system runs on a familiar network or because the code hasn't changed recently.

Users should rely on updates from the applications they use and from Ethereum's client and developer communities. Be cautious about unverified claims that "all contracts are vulnerable" or that a mainnet exploit is actively underway. Based on the available information, the narrower conclusion is this: a Hoodi testnet activation was postponed after a security firm reported potentially important compatibility issues in some contracts.

Conclusion

The Glamsterdam delay shows why protocol upgrades need to be tested against how deployed contracts behave - not just against client implementations or feature checklists. Gas rules shape execution, and when contracts use gas availability to decide whether something can be retried, changes to accounting can shift security assumptions even if the contract code doesn't change.

For now, the scope is a postponed Hoodi testnet fork, 13 reported real-world examples, and a broader assessment that was still ongoing at the time of reporting. The practical approach is to test failure paths, follow client guidance, and wait for verified updates rather than speculate about mainnet impact.

If you maintain Ethereum contracts, review your external-call and retry logic before the next testnet schedule gets announced. If you operate a node, use the version your client team recommends. And in protocol work, delaying a fork to understand a real risk isn't a delivery failure - it's part of delivering an upgrade that can stand up in production.

Frequently Asked Questions

No. The planned activation on the Hoodi testnet was postponed. Developers had not announced a new Hoodi date, and the report did not say the upgrade was cancelled or that its mainnet target had been formally withdrawn.
The reported action concerns the Hoodi testnet. The announcement does not say mainnet users need to move funds or change wallets, but contract teams should assess whether their code relies on gas and failure assumptions that Glamsterdam could change.
It is a tactic where someone deliberately provides too little gas for an operation to complete, making a valid action fail. It can become a lasting problem if a contract records the failure or prevents a retry in a way that can be exploited.
ChainSecurity reported 13 real-world examples and said it was contacting the affected projects through responsible disclosure. That may not be a complete count; the Ethereum Foundation was assessing wider exposure.
Operators should follow guidance from their execution-client and consensus-client teams. Initial advice was to use an older release without the upgrade scheduled or wait for a client release that removes the Hoodi activation.

Related articles