Ethereum Glamsterdam: EIP-8037/8038 Risks
Learn why EIP-8037 and EIP-8038 have delayed Ethereum’s Glamsterdam testnet rollout, which contract assumptions to review, and how teams can assess exposure.

Ethereum's Glamsterdam Upgrade: What EIP-8037 and EIP-8038 Mean for Smart Contracts
Ethereum's Glamsterdam upgrade is currently being tested on testnets, but security findings have changed the rollout plan. Chainsecurity flagged projects that could end up vulnerable after the upgrade because their code depends on assumptions about gas costs and state accounting. EIP-8037 and EIP-8038 adjust gas consumption for certain operations and change how gas is charged for state - assumptions that some projects may be treating as fixed.
For now, AllCoreDevs has decided to delay the hardfork process: they won't fork the Hoodi testnet until the issues are sorted out. Meanwhile, work on Hegota continues in parallel. How any individual project is affected depends on its code and on which invariants it leans on. The available announcement doesn't spell out the eight affected invariants, and it doesn't claim that every contract is at risk.
So this is a practical reminder for developers, auditors, and protocol teams: check your systems before the upgrade moves forward. This article lays out what's known, how gas-related assumptions can turn into security dependencies, and how to run a focused review without confusing a compatibility mismatch with a confirmed exploit.
What is happening with Glamsterdam and the testnet schedule?
Glamsterdam is the next Ethereum upgrade and it's going through testnet testing right now. During that work, Chainsecurity found projects that may become vulnerable after the upgrade because they rely on invariants that EIP-8037 and EIP-8038 will change. Broadly, the changes are about gas charged for certain operations and how gas is charged for state.
In response, AllCoreDevs chose to pause the hardfork process and not fork Hoodi until the underlying assumptions (and any related specification questions) are resolved. This is about the upgrade process itself - not proof that Ethereum mainnet has changed already, and not confirmation that any specific project has been exploited. The announcement also doesn't give a new Hoodi fork date, so it's worth resisting the urge to treat this as a small, predictable delay.
What the announcement confirms - and what it does not
The announcement makes a few things clear:
- EIP-8037 and EIP-8038 change gas charging in ways that can invalidate existing assumptions.
- Chainsecurity identified projects that may be vulnerable after Glamsterdam.
- The Hoodi fork is paused while the affected assumptions and potential specification changes are reviewed.
What it does not do is list every affected project, explain the eight invariants in detail, or say that every contract using a particular pattern is vulnerable. The Ethereum Foundation points to a repository with explanations, examples, and prompts, but the announcement itself doesn't include that detail. Teams should use the invariant material directly and assess their own code rather than guessing exposure from a summary.
Why continuing test work matters
Testnets are where teams can see how protocol changes interact with real applications before those changes land on mainnet. When a finding shows up during this phase, it gives application teams a chance to investigate - and gives protocol maintainers time to decide whether a specification change is actually needed.
It also underlines why testnet schedules shouldn't be treated like a guarantee. Even if the protocol behaves exactly as specified, an application can still break in a way that stems from an unstated - or now outdated - assumption. That means review has to cover both sides: what the protocol is intended to do and how applications rely on it.
The announcement also says work on Hegota is continuing in parallel. That doesn't remove the Glamsterdam concerns, and it doesn't mean application teams can ignore them. It only means the following upgrade isn't being halted by this particular review.
Why can gas and state changes affect existing contracts?
Gas is part of Ethereum's execution model, but contracts (and the systems around them) can treat gas consumption as an input to their own logic. A contract might branch based on whether enough gas remains, compare the relative cost of operations, or decide whether a state-changing action can fit inside some budget. If a protocol update changes the cost of an operation, any contract that depends on the old cost relationship can behave differently than intended.
That said, the risk isn't "gas changes will break everything." Many contracts don't need to know an exact gas cost in order to work. The danger tends to show up in code paths where gas behavior is baked into control flow, safety checks, or operational assumptions. Whether a specific pattern is impacted has to be verified against the actual EIP changes and the named invariants.
Invariants are dependencies, even when they're not written down
An invariant is a condition a system expects to stay true. Sometimes it's explicit in a specification. Sometimes it's embedded in contract logic. Often, though, it's just assumed by the developers who built the system.
If an upgrade breaks that assumption, the code can still compile and deploy, while its runtime behavior changes in ways that matter for safety or reliability.
For a practical review, look for assumptions about the relationship between gas use and execution, and about how state-affecting operations are priced. These are the right categories to investigate - not a claim that we already know how each of the eight Glamsterdam invariants maps to a specific vulnerability. The announcement doesn't provide enough information to name those invariants or connect each one to a particular failure mode.
A useful way to frame it is to separate protocol compatibility from application safety. Compatibility is whether the contract can execute under the new rules. Safety is whether it still preserves the properties that users and integrators care about. A contract might still execute, but fail sooner (for example, by running out of gas earlier than expected) or take a different conditional path.
The code to inspect extends beyond Solidity
Assumptions may live outside your main contract code. Transaction builders, relayers, bots, deployment scripts, monitoring systems, and operational runbooks can all depend on execution behavior. In some setups, an off-chain service estimates or applies gas limits before submitting transactions. Changes in gas charging can affect that workflow even if the contract itself never explicitly "reads" gas.
That's why limiting the review to on-chain source code can miss real exposure. Teams should map the full transaction path: who constructs the call, what assumptions they use, which contracts execute, how failures are handled, and what downstream systems do based on the result. The goal isn't to assume every layer is vulnerable - it's to avoid treating on-chain code as the entire system.
How should teams check whether their projects are affected?
Start with the Glamsterdam invariant material, not a generic search for "gas" in your codebase. The Ethereum Foundation's repository is meant to help teams verify their projects, with short explanations, examples, and prompts. For each listed invariant, compare it to the behavior of your contracts and surrounding services. If a code pattern looks relevant, that's a reason to investigate - not proof of a vulnerability.
A review is also much more useful when it results in something you can point to later: which assumption was tested, where it appears, what changes under the new rules, and what evidence supports the conclusion. That makes it easier to separate a real issue from a false positive and gives auditors or protocol researchers the context they need to respond.
A practical review workflow
- Inventory the system. List deployed contracts, upgradeable implementations, libraries, relayers, automation, transaction builders, and critical integrations. Include vendor/partner systems when their behavior affects your outcomes.
- Read each invariant and example. Write the assumption in plain language. Don't rely on the EIP number or a generic "gas changes" description - use the invariant material itself.
- Map assumptions to code and operations. Identify the relevant execution paths, then trace how transactions are constructed, submitted, and handled. Include failure paths, not only the "happy path."
- Test the changed behavior. Recreate the relevant path in an environment set up for the proposed rules. Compare before/after behavior, including gas usage, state changes, reverts, and how off-chain components react.
- Assess consequence and reachability. Decide whether an external user or automated process can trigger the path, what assets/functions it affects, and whether the outcome is a security issue, a reliability problem, or something with no meaningful impact.
- Document and escalate. Keep the invariant, affected component, reproduction steps, expected/observed behavior, and mitigation options together. If you find a likely issue, contact the Glamsterdam team at glamsterdam@ethereum.org.
How to prioritize when time is limited
If you can't review everything at once, start with paths that control access to funds, permissions, settlement, liquidations, or other critical protocol actions. Then move to high-frequency automation and transaction flows where a failure could interrupt service or create repeated costs. That's a triage approach - not a substitute for checking every relevant invariant against your project.
For each path, ask four questions:
- Does it depend on an assumption named in the invariant material?
- Can the operation be reached in production?
- What changes under the proposed rules?
- What happens if it fails or behaves differently?
If the answer to the first question is "yes," test it. That alone doesn't prove exploitability, but it tells you where to spend time.
What a useful finding report contains
A solid report should point to the relevant invariant, the affected contract or service, and the exact transaction or workflow that shows what happens. Include the test environment and rules used, the expected result, the observed result, and the practical impact. If there's a potential fix, describe trade-offs and whether it changes anything users will notice.
This level of detail helps reviewers make a pragmatic decision - whether the code needs changing, whether a specification adjustment could remove the problem, or whether the project's assumption is harmless under the new rules. Avoid treating a "pattern match" as a confirmed vulnerability unless you can show reproducible impact.
What does the delay mean for Ethereum projects and developers?
For application teams, the delay is a chance to investigate - not a reason to wait quietly for a final schedule. The finding already indicates that some projects rely on assumptions affected by the proposed changes. If you identify dependencies early, you'll have more options: adjust code, update operational procedures, or gather evidence that whatever pattern you worried about isn't actually an issue.
For the Ethereum upgrade process, the pause creates time to evaluate the reports and decide whether the specification should change. The announcement says the goal of upcoming AllCoreDevs discussions is to understand what may break and whether specification changes could prevent those problems. That leaves the outcome open. It would be premature to assume the EIPs will be rolled back - or that applications must absorb every change exactly as written.
Separate project mitigation from protocol changes
A specification-level change can help multiple projects if the same assumption is widely used. But changing the specification also has costs: it can shift the intended upgrade behavior, require additional testing, and affect projects that already adapted to the current proposal. A contract-level fix might be faster for one team, but it can introduce its own risks or require coordinated upgrades.
Which approach makes sense depends on the specific invariant, how widely it's relied upon, and how severe the consequences are. Protocol reviewers are more likely to act on concrete evidence than on a broad request based on an untested concern. On the other hand, project teams shouldn't assume a specification change will arrive in time to replace their own mitigation work.
Keep upgrade readiness tied to evidence
A simple readiness tracker keeps the work grounded in facts rather than vibes:
- Not assessed: The project hasn't compared its system with the listed invariants.
- Under review: Possible dependencies are identified, but not tested.
- Tested, no impact found: Relevant paths were evaluated under the proposed rules, and evidence was recorded.
- Issue confirmed: A reproducible behavior change has a material consequence and has been reported.
- Mitigated and retested: A code, configuration, or process change was tested again against the same scenario.
These labels are more informative than a single "Glamsterdam-ready" checkbox. They reflect what's known, what's still uncertain, and what evidence supports a decision. They also make it easier to revisit the assessment if the EIPs or the invariant guidance changes.
The biggest operational risk isn't that the testnet fork is delayed. It's discovering late that a critical service depends on behavior nobody documented or tested. Doing a focused review now is usually less disruptive than rushing an urgent fix after an upgrade date is set.
Conclusion: treat the upgrade as a compatibility review
Glamsterdam's testnet delay is a prompt to check assumptions, not a verdict that Ethereum contracts are fundamentally broken. EIP-8037 and EIP-8038 change gas charging in ways that can invalidate some project invariants, and the specific exposure depends on each system's code and operational behavior.
Use the invariant material to guide a bounded review, test the relevant transaction paths, and record evidence before deciding whether you need a fix. If you find a reproducible issue, report it to the Glamsterdam team. The goal is simple in practice: make upgrade decisions with a clear view of what breaks, what doesn't, and why.