NewsCryptoEthereum Gas Proposals Could Let Callers Skip Internal Payments

Ethereum Gas Proposals Could Let Callers Skip Internal Payments

Author: Coindoo·

Key Takeaways

  • •A proof-of-concept simulation showed that selected gas limits could let a vault complete withdrawals while skipping its 2.5% component payment under the tested Glamsterdam rules.
  • •A separate Sepolia simulation showed OP Stack finalization succeeding at the transaction level while bridge delivery failed and funds were not credited.
  • •The Ethereum Foundation estimates that approximately 10,000–15,000 contracts may be affected, while auditors reported 200 combined findings from their searches.
  • •Potential mitigations include updating gas estimation, increasing application gas settings, upgrading contracts, supporting retries, or changing protocol rules for immutable contracts.
  • •Core developers will review the proposals and possible specification changes on November 19, with the Hoodi testnet fork paused until the issue is resolved.
Ethereum Gas Proposals Could Let Callers Skip Internal Payments

Ethereum developers are examining whether two proposed gas-pricing changes could allow callers to make certain internal payments fail while the surrounding transaction still succeeds. The issue emerged from testing of EIP-8037 and EIP-8038, two proposals that led AllCoreDevs to pause the Hoodi testnet fork, according to the Ethereum Foundation’s November 6 update.

The findings include simulations in which a caller-selected gas limit caused a vault to skip a 2.5% payment, as well as tests in which an OP Stack withdrawal was finalized but bridge funds were not credited. The Ethereum Foundation estimated that approximately 10,000–15,000 of roughly 90 million contracts could be affected. Core developers are scheduled to discuss EIP-8037 and EIP-8038 at the November 19 execution-layer call.

A withdrawal that pays everyone but one

The clearest example comes from a proof-of-concept repository published under the GitHub account mejango and cited in the developer discussion: https://github.com/mejango/glamsterdam-pocs. The vault sends 2.5% of each withdrawal to a separate component contract inside a try block. If that payment reverts, the vault keeps the share and pays the user anyway. This pattern is commonly used to prevent one malfunctioning component from blocking every withdrawal.

The author ran the same call with gas limits ranging from 30,000 to 900,000 through eth_simulateV1 on public RPC endpoints. The tests were conducted once against Ethereum mainnet and once against Sepolia, which the repository says already applies Glamsterdam gas rules. Nothing was deployed.

On mainnet, every tested gas limit either reverted the entire withdrawal or paid the component. Under the tested Glamsterdam rules, a band approximately 112,000 gas wide allowed the withdrawal to complete while skipping the payment.

These results are the author’s simulations. Coindoo has not reproduced them, and they do not describe an exploit involving a live contract.

The caller chooses the outcome

The person or system calling the withdrawal sets the outer gas limit. According to the repository, that turns the gas band into a control mechanism: a caller can deliberately choose a limit within the band, causing the component payment to fail while allowing the withdrawal itself to proceed.

The vault has no way to distinguish that situation from an accidental failure. Its contracts are immutable, so logic designed to tolerate a broken component also tolerates a component that is deliberately underfunded.

Under current mainnet rules, the same attempt fails. A limit too low to fund the component also leaves too little gas to complete the remaining work, causing the entire transaction to revert.

Why the payment fails while the fallback survives

The result depends on the combined effects of the two proposals. EIP-8038 raises the gas cost of reading and writing state, meaning that a budget previously sufficient for the component’s work may run out sooner. EIP-8037 separates the cost of creating new state from ordinary execution gas and increases that cost. Coindoo has previously covered the implications for onboarding costs at https://coindoo.com/ethereum-could-raise-the-cost-of-onboarding-new-users/.

The second change is what allows the fallback to remain executable. ChainSecurity’s October 13 analysis, “Glamsterdam Gas”, explains that state-creation charges are taken from a separate pool that is restored when a call fails. It also says that state charges paid from regular gas during a failed call are returned to the caller. As a result, a contract can have more gas remaining after a failed call than it would under current rules.

ChainSecurity’s worked example involves writing to a fresh storage slot. Under current rules, the operation costs 22,100 gas. A failure handler with approximately 15,000 gas remaining therefore runs out of gas and the transaction reverts. Under the reviewed Glamsterdam specification, the same write costs 12,100 execution gas, while a 97,920-gas state charge is taken from the separate pool. That leaves enough gas for the write and a short continuation.

The write is not cheaper overall; the expensive portion is paid from a different pool. The vault scenario requires both effects: the component call fails earlier because the work costs more, while the vault’s fallback completes because it no longer runs out of gas. A contract that relied on running out of gas to force a rollback could therefore reach a different state.

ChainSecurity limits that conclusion to specific call patterns. According to the summary of the November 16 testing call, most findings reported so far result from the increased costs rather than from the separate state-creation pool.

When the default gas estimate falls into the gap

A higher gas price per unit does not change this behavior because price does not add gas units to an internal call. A higher gas limit can help in the vault example because sufficiently large limits fund the component, but that only happens if the software setting the limit chooses a high enough value.

The repository’s second test examines what happens when standard gas estimation is used. It models an OP Stack withdrawal being finalized on Ethereum with the real OptimismPortal2 and L1CrossDomainMessenger contracts. The delivered message requests a fixed 375,000 gas.

On mainnet, finalizing with the eth_estimateGas result of 931,416 delivered the message. Under Glamsterdam rules on Sepolia, finalizing with an estimate of 1,517,344 succeeded at the transaction level, but the messenger recorded the delivery as failed and the funds were not credited. Doubling the gas limit delivered the message.

The repository presents the estimate as the value a wallet or relayer would send, meaning the user would not have done anything unusual. Recovery remains possible because the messenger allows anyone to replay a failed message, but doing so requires a third, manual transaction and another gas payment.

The two runs used different messenger versions: 2.11.1 on mainnet and 2.13.0 on Sepolia. The comparison does not isolate the effect of that difference.

The two gas sweeps

Vault withdrawal — current mainnet rules

  • 30,000–106,000: the entire withdrawal reverts
  • 108,000–898,000: the component is paid

Vault withdrawal — Glamsterdam rules

  • 30,000–180,000: the entire withdrawal reverts
  • 182,000–294,000: the withdrawal succeeds and the payment is skipped
  • 296,000: the transaction reverts
  • 298,000–898,000: the component is paid

OP Stack finalization — mainnet

  • 400,000–900,000: the transaction reverts and must be retried
  • 925,000–10,000,000: the message is delivered

OP Stack finalization — Glamsterdam rules

  • 400,000–1,000,000: the transaction reverts
  • 1,025,000–1,600,000: finalization succeeds, but delivery is recorded as failed
  • 1,625,000–10,000,000: the message is delivered

The Glamsterdam results were simulated on Sepolia. The OP Stack runs were pinned to a single L1 block.

What a successful receipt does not show

In both tests, the transaction receipt reports success. Receipt status covers only the outer call. It does not show whether a call caught inside a try block, or a message handed to a bridge messenger, accomplished its intended task.

Verification requires checking the relevant evidence: a balance change or event from the component in the vault case, and, for OP Stack withdrawals, whether the messenger emitted RelayedMessage or FailedRelayedMessage.

A bridge interface that labels a withdrawal “finalized” based only on the receipt can therefore show a completed withdrawal before any funds have arrived.

The affected contracts and possible fixes

At the November 16 testing call, the Ethereum Foundation’s Marius estimated that around 10,000–15,000 of approximately 90 million contracts would be affected, according to the meeting’s auto-generated summary. The summary does not explain how that figure was calculated. It also gives a separate value-at-risk estimate of “a few hundred thousand dollars,” without explaining how that number was produced.

A contract count is not the same as an application count, and an affected contract does not necessarily place funds at risk.

Auditors presented their own figures during the call. ChainSecurity reported 152 findings, increasing to 200 when combined with the Ethereum Foundation’s internal search. The summary describes most findings as easy to mitigate, although some require contract upgrades or redeployment.

The available fix depends on where the outdated gas assumption exists:

  • Wallets and RPC providers can change their gas-estimation methods, which is the layer implicated by the OP Stack result.
  • Applications with adjustable gas settings can increase those values and retest them.
  • Upgradeable contracts can deploy a new implementation, usually after a governance vote.
  • Immutable contracts cannot be patched. Their options include a supported retry, an external workaround, moving users to a replacement contract, or changing the protocol rules.

The last category places the issue with core developers as well as application teams. Coindoo previously examined that compatibility question at https://coindoo.com/ethereums-next-upgrade-could-change-how-old-contracts-run/.

The testing-call summary also assigns follow-up work involving affected application teams, L2s and OP Stack chains. That work includes testnet replays intended to identify contracts that have not yet been found.

What the November 19 call could decide

Core developers will review the findings at the November 19 execution-layer call. The Ethereum Foundation says no decision has been pre-committed for that meeting, while the testing-call summary lists deciding whether to proceed with EIP-8037 and EIP-8038 as an action item.

Options raised on November 16 included proceeding as planned, dropping the proposals, waiting for contract-size limit increases, or delaying the changes. Developers supporting the current plan cited the post-quantum roadmap. One developer warned that dropping the proposal would prevent large contracts from being deployed.

The Foundation’s update says several revisions to the specifications are being prototyped. Each revision is being documented in terms of the problems it addresses and the other invariants it could break.

The Hoodi testnet fork remains paused until the issue is resolved. The gas bands described above apply to the tested version of the proposals; any specification revision would change the rules governing those simulations.