Ethereum Glamsterdam Upgrade 🚨 Delayed: Gas Risks & Griefing12 min read2,379 words

Ethereum Glamsterdam Upgrade 🚨 Delayed: Gas Risks & Griefing

Ethereum Glamsterdam upgrade delayed: the Ethereum testnet fork is on hold after gas risks flagged. Learn what changed, and smart contract security tips before launch.

Ethereum Glamsterdam upgradeEthereum testnet forkinsufficient gas griefingEthereum smart contract securityEthereum gas changes
Ethereum Glamsterdam Upgrade 🚨 Delayed: Gas Risks & Griefing

Why Ethereum Delayed the Glamsterdam Testnet Fork

Ethereum developers have postponed the Glamsterdam upgrade on the Hoodi testnet after security researchers raised concerns about proposed changes to gas accounting. This isn't just about gas prices shifting. Some contracts use the amount of gas left during a transaction as part of their security logic, and the proposed rules could change how that logic behaves when an operation fails.

The delay gives developers time to evaluate whether two proposals - EIP-8037 and EIP-8038 - could weaken defenses against insufficient gas griefing. ChainSecurity says it found 13 real-world contract examples that could be affected, and it's coordinating responsible disclosure with the teams involved. It has not publicly named the contracts or confirmed that they've been exploited.

For users, the immediate impact is limited to a postponed testnet deployment, not a confirmed change to Ethereum mainnet. For developers, the issue is more practical: existing contracts may have baked-in assumptions that need review before any new gas rules go live. This article breaks down the reported risk, why the testnet matters, and what teams can do while the upgrade is rechecked.

What Happened to the Glamsterdam Upgrade

The Ethereum Foundation postponed the Glamsterdam hard fork on the Hoodi testnet. The deployment was originally set for October 26, but developers delayed it to examine how the proposed changes could interact with smart contracts already deployed on Ethereum.

The schedule change followed a warning from ChainSecurity. On October 13, the researchers said two proposals included in Glamsterdam - EIP-8037 and EIP-8038 - could affect protections against insufficient gas griefing. Ethereum contributors responded by urging reassessment of the fork before moving forward.

ChainSecurity later said it identified 13 real-world examples of contracts that could be affected. It said it's working on responsible disclosure with the relevant projects rather than publishing details that could increase risk. ChainSecurity also urged developers to review their contracts, though the public reporting doesn't show that all 13 examples are vulnerable in the same way or that an attack has occurred.

Hoodi is a testnet, not Ethereum mainnet

Hoodi is one of the networks Ethereum developers use to test protocol changes before they reach mainnet. A testnet fork lets developers, infrastructure providers, and application teams see how the rules behave in a live-like environment without making the change on Ethereum mainnet.

So the distinction matters. This postponement doesn't mean Ethereum mainnet has been upgraded, and it doesn't mean every contract that checks gas is already at risk. It means a planned test deployment was paused while developers look more closely at what the proposed gas rules could change.

Glamsterdam had already been activated on Sepolia on October 6, according to the source report. The Hoodi delay adds another stage of testing and review, but it doesn't, by itself, tell us what the final mainnet schedule will be. Developers had been considering an early-December mainnet timeline, but that depends on results from testing - so with Hoodi paused, the date isn't confirmed.

The issue is broader than one contract

A protocol upgrade changes shared execution rules. That means an application doesn't have to be newly deployed to run into those rules - existing contracts can behave differently after the network changes even if their code is unchanged.

That's why compatibility reviews matter. A contract's safety can depend on assumptions about execution, failure behavior, and how much gas remains - assumptions that were reasonable when the contract was written. If the upgrade changes one of those underlying assumptions, developers need to verify that the contract's control flow still leads to the intended outcome.

Why Gas Changes Could Affect Contract Security

Ethereum uses gas to meter computation and other operations. A transaction includes a gas limit, and the network deducts gas as execution carries out the requested work. If execution runs out of gas, it can't keep going indefinitely; what happens next depends on where and how the failure occurs.

Smart contracts can also use gas-related checks inside their own logic. Those checks aren't a replacement for proper access control or clear error handling, but they can act as safeguards in specific execution paths. So even a protocol change intended to improve the broader gas model can still matter for contract behavior.

ChainSecurity's concern is that, under the proposed rules, gas could be returned to a contract after an operation fails. In some situations, that could let execution continue in a path the contract's existing logic expected to stop. If a contract relies on the remaining gas to detect that something failed, the changed behavior could undermine that assumption.

How insufficient gas griefing works

In insufficient gas griefing, a malicious caller deliberately provides too little gas for a legitimate operation to complete. The goal isn't always to halt the whole network. Often, the attacker is trying to force a contract into an unexpected failure path or trigger a specific outcome that hurts another user.

Take a contract that processes a user's claim. If an operation fails, the contract should keep the claim intact or allow the user to try again. But if the contract instead marks the claim as used, removes it, or disables the retry path, a caller could potentially cause the user to lose access to an operation that should have succeeded.

That's one possible outcome, not a claim that every contract behaves the same way when something fails. The real risk depends on the contract's code and how it handles errors, gas, and state changes. ChainSecurity's warning is that the proposed gas behavior could affect some existing safeguards - so developers should test their assumptions, not assume every gas-related check is automatically broken.

Why a gas check can be a hidden dependency

A contract might look like it depends only on normal application logic, while the real security property depends on execution details. For example, a developer might assume that a failed call leaves the contract with too little gas for later steps, or that a particular failure will stop the broader operation. If the protocol's gas accounting changes, later steps could become reachable under conditions the original author didn't anticipate.

The challenge is that these assumptions can be difficult to spot in a quick review. Searching for a gas-related check is a good start, but it doesn't tell you whether the contract is actually vulnerable. Reviewers need to follow the relevant execution path: what fails, whether state has already changed, whether execution continues, and what the caller controls.

ChainSecurity has also cautioned that Glamsterdam wouldn't make every gas-related security check unreliable. The risk appears to be selective. Developers should establish whether their contracts depend on behavior that the proposals would affect. Treating every contract as vulnerable would be an overreaction, and assuming current checks remain safe without testing would be a mistake.

What Developers and Projects Should Do Now

The most useful response is a targeted compatibility review, not a sweeping rewrite. Teams should identify code that depends on gas remaining, failed calls, retries, or state updates after an operation that might fail. Then they should test those paths against the proposed rules and write down what behavior they expect.

A practical review can follow this sequence:

  1. Inventory relevant contracts. Include production contracts, libraries, inherited code, and third-party components. A dependency can introduce exposure even if the application team didn't write the logic.
  2. Search for gas-sensitive assumptions. Look for checks involving gas availability and for patterns that condition later execution on whether a call or operation succeeded. This is a triage step, not a vulnerability verdict.
  3. Trace state changes around failures. Check whether a failed operation can still lead to a claim being consumed, a retry being disabled, or other persistent state changes. Pay attention to what gets committed and what gets reverted.
  4. Test adversarial inputs. Try execution paths where the caller supplies limited gas or where a subordinate operation fails. Compare the contract's current behavior with what's expected under the proposed upgrade rules.
  5. Review and retest dependencies. If the contract uses a library or external component, confirm whether its assumptions matter to the calling contract. Test the full path, not just an isolated unit test.
  6. Escalate privately when appropriate. If a team finds a plausible issue in a live contract, it should follow responsible disclosure and coordinate with affected parties before publishing technical details.

The point is to focus on consequences, not just surface-level code patterns. A gas check can be irrelevant in one design and crucial in another. What matters is whether a caller can influence failure conditions and whether that influence could trigger an unintended state transition or block a legitimate retry.

Test against the upgrade's actual rules

Tests only help if they match what's being proposed. Teams should use the relevant testnet environment and tooling as it becomes available, and keep test cases focused enough that the result is meaningful. A passing general test suite doesn't automatically prove that a specific gas-related assumption is still safe.

The test should cover both outcomes: the operation succeeds as intended, and the operation fails under constrained or adversarial conditions. In both cases, verify what the contract state looks like afterward and whether the user can recover or retry. Checking only whether a transaction "worked" can miss the real problem.

This is also where deployment operations come in. Wallets, indexers, and gas estimators may rely on assumptions about the gas model. The Ethereum Foundation has previously warned that some tools could break with Glamsterdam. Application teams should include off-chain components in their compatibility checks. The security review and the infrastructure review are related, but they're not the same job.

What the Delay Means for Ethereum

A hard fork isn't just a set of protocol changes developers merge and move on from. It's a coordinated update that touches client software, node operators, applications, and supporting infrastructure. Delays can be frustrating - especially for teams planning releases around a target date - but pushing forward without understanding a credible compatibility risk can end up costing more.

Here, postponing Hoodi testing reflects a specific choice: the goal isn't to hold to the calendar no matter what. It's to determine that the proposed rules work safely with the contracts and tools already deployed on top of Ethereum. A testnet schedule is useful only if it generates evidence that supports a responsible mainnet decision.

The report doesn't include a revised Hoodi date or a confirmed mainnet date. Early December was on the table, but only if testing succeeds. Treat that as a planning assumption, not a promise. If your releases depend on the earlier timeline, don't assume it's fixed until Ethereum developers publish an updated schedule.

A delay is not proof the proposals are unusable

The reporting doesn't say EIP-8037 or EIP-8038 must be dropped. It says the proposals need more review because developers want to understand how they interact with existing contracts. Developers could revise the proposals, adjust their implementation, document mitigations, or decide that additional testing resolves the concern. The public information doesn't indicate which path will be taken.

There's a trade-off, and it's worth saying out loud: improvements to gas efficiency or a cleaner protocol model are only useful if they don't change security assumptions that deployed applications rely on. A technically "elegant" change isn't automatically a good upgrade if it creates new failure modes quietly. On the other hand, delaying forever has its own costs. Testing is the way teams make that trade-off visible before mainnet activation.

For users, the stance is restrained: the source report doesn't indicate a confirmed exploit or a specific need to take action based only on the testnet delay. For developers, the next step is more concrete: review contracts that depend on gas-sensitive failure behavior and keep an eye on official updates as the testing plan shifts.

Frequently Asked Questions

Glamsterdam is a planned Ethereum network upgrade that includes proposed changes to gas behavior. The source report discusses its testing on Ethereum testnets and concerns that two proposals, EIP-8037 and EIP-8038, could interact with security assumptions in some existing smart contracts.
The Ethereum Foundation postponed the planned Hoodi deployment after ChainSecurity warned that the proposed gas changes could affect safeguards against insufficient gas griefing. Developers are investigating how the proposals interact with deployed contracts before continuing testing.
No. The postponed event was a Hoodi testnet fork. The report says Glamsterdam had previously been activated on Sepolia, but it does not say the upgrade was activated on Ethereum mainnet. The mainnet schedule remains uncertain pending further testing.
No. ChainSecurity said the changes would not make all gas-related security checks unreliable. The risk depends on how each contract handles failures, gas and state changes. Developers should review relevant execution paths rather than assume every contract is affected.
Teams should identify contracts and dependencies that rely on gas availability or failure behavior, then test whether constrained gas can lead to unintended state changes or block a retry. If they find a credible issue in a live contract, they should coordinate responsible disclosure.

Related articles