Glamsterdam Gas Repricing: EIP-8037 and EIP-8038 for Developers

Gas-sensitive Ethereum code can work for years and still fail after a protocol upgrade. That is the practical warning behind Glamsterdam gas repricing: EIP-8037 and EIP-8038 change the price of creating, reading, and writing persistent state. This guide connects those changes to what is blockchain, then shows developers what to review before mainnet activation.

The Ethereum Foundation says both proposals are scheduled for Glamsterdam and are already running on development networks. However, each EIP is still marked Review on the official EIP site. Treat current constants and mechanics as the test target—not an excuse to freeze assumptions into production code.

What Glamsterdam gas repricing changes

Think of Ethereum state as a public warehouse that every full node must maintain. Reading a box takes work. Updating its label takes more work. Adding a new shelf creates a storage obligation that future nodes inherit indefinitely. The old gas schedule bundled some of those costs together and no longer tracked all of them closely.

EIP-8037 focuses on state creation: new accounts, new storage slots, and deployed bytecode. It harmonizes these operations around a cost-per-state-byte parameter and introduces a separate state-gas dimension.

EIP-8038 focuses on state access and writes. It separates an operation's price into access, write, and creation components. The warm-versus-cold rules remain, but several constants change and explicit account-write and storage-write charges appear.

This is more precise than saying “gas goes up.” Pure computation and already-warm reads are not the same resource as permanently expanding the database. The repricing aims to charge each bottleneck more directly so Ethereum can raise block capacity without making state growth or disk access invisible.

How EIP-8037 creates a state-gas dimension

Today, developers usually reason about one gas counter. EIP-8037 proposes two block-level resource counters:

• execution gas for computation and ordinary execution work
• state gas for persistent state creation

A transaction still supplies one gas limit and pays the combined gas it uses. Internally, the proposal uses a state-gas reservoir alongside the familiar execution gas_left. At block level, Ethereum tracks cumulative execution gas and cumulative state gas, and the block header's gas_used becomes the larger of the two totals.

The warehouse analogy helps here. A block can contain many workers doing calculations or many crews installing permanent shelves, but neither resource may exceed the block limit. Light use of one dimension does not erase heavy use of the other.

The current specification sets CPSB, or cost per state byte, to 1,530 gas. It derives that value from a 150 million reference block gas limit and a target of roughly 120 GiB of annual state growth at average utilization. New storage slots are modeled as 64 state bytes, new accounts as 120 bytes, and deployed code is charged per byte. These are specification parameters under review, not timeless application constants.

One subtle result is that EIP-7825's transaction cap applies to the execution side, while a larger total transaction gas limit can fund state creation. Wallets and RPC nodes therefore need updated estimation logic rather than a larger hardcoded buffer.

How EIP-8038 reprices reads and writes

EIP-8038 keeps the basic idea that the first state access is cold and later access in the same transaction is warm. It changes how the bill is assembled.

Component	What it represents	Current review-spec example
Cold account access	First account touch in a transaction	3,000 gas
Warm access	Repeated account or slot touch	100 gas
Account write	Change to account leaf data	9,000 gas
Storage write	Net change to an existing storage slot	10,000 gas
Access-list address	Prepaid account access	2,900 gas
Access-list storage key	Prepaid slot access	2,000 gas

Cold storage access remains 2,100 gas in the current draft. EXTCODESIZE and EXTCODECOPY also gain an extra warm-access charge because clients perform a second database read to obtain code information.

Storage writes are net-metered against the slot's value at transaction start. Moving a slot away from that original value incurs the write component; restoring it can reverse that component through the refund counter, subject to the protocol's refund cap. Creating a previously empty slot also adds EIP-8037 state gas.

If your application constructs access lists, revisit the arithmetic in our EIP-2930 access-list guide. The mechanism remains useful, but cached 2,400/1,900 constants will no longer describe the proposed Glamsterdam schedule.

Which contracts can break or degrade

The Ethereum Foundation's August 2026 developer advisory reports that replaying historical mainnet transactions produced four broad outcomes: no change, success with changed gas use, failure fixed by raising the submitted gas limit, and potential breakage even with a substantially higher limit. It says the large majority of transactions were unaffected.

The exposed patterns are more useful than a headline percentage:

1. Fixed gas forwarded to an external call. A callee that previously fit inside a hand-picked allowance may now run out of gas after state access or writes cost more.
2. transfer or send assumptions. Solidity's 2,300-gas stipend is not a general compatibility guarantee. Recipient logic that touches state can fail as opcode pricing evolves.
3. Branches based on gasleft(). Repricing moves thresholds. EIP-8037's reservoir model also makes low-level gas accounting more complicated than subtracting two GAS readings.
4. Presigned transactions with fixed gas limits. A valid signature cannot repair a gas limit that is too low under the activated schedule.
5. Cached estimator constants. Wallets, relayers, and RPC middleware that reproduce old formulas can under-estimate otherwise valid transactions.

Contract deployment and storage-heavy loops deserve special attention. Review the actual storage layout—not just variable names—using the Ethereum storage-slot guide, then test representative state shapes. A path that updates ten existing slots is not equivalent to one that creates ten new slots.

A practical testing checklist

1. Search before changing code

Use the Ethereum Foundation's linked affected-contract search as a triage tool. Then search your source and generated transaction builders for gasleft(), .transfer, .send, {gas: ...}, fixed gas-limit fields, and locally copied opcode tables. Absence from a replay list does not prove safety for every future input.

2. Reproduce realistic state

Test empty and populated mappings, first-time users, repeated users, contract creation, value transfers to new accounts, and both cold and warm access paths. Fork-based tests should pin the intended protocol rules and preserve enough state to exercise the real branch.

3. Run on the designated test network

The advisory points developers to the Platåberget development testnet for the new schedule. Confirm the current network and client instructions through official Ethereum channels before funding or deploying anything. A development network can reset, and its behavior is not a mainnet activation guarantee.

4. Fix the assumption, not only the symptom

If a transaction succeeds with a higher submitted limit, update estimation and user-facing limits. If an internal call uses a fixed allowance, determine whether forwarding available gas with explicit failure handling is safe for that design. Do not blindly remove a gas boundary that was serving as a security control.

5. Re-run after specification changes

Both EIP pages currently carry Review status. Pin the EIP revision, client version, compiler version, and test date in engineering notes. Repeat the suite against public testnets and final client releases before activation.

Risks and limitations

• Specification risk: parameter values and edge-case accounting can change while EIP-8037 and EIP-8038 remain under review.
• Incomplete replay coverage: historical calls cannot represent every future input, state configuration, proxy implementation, or privately submitted transaction.
• Gas-limit risk: increasing a transaction limit does not force all gas to be spent, but it also does not fix an internal call that forwards a hardcoded amount.
• Security trade-offs: changing call behavior can affect reentrancy, failure isolation, and denial-of-service exposure. Review the security purpose of an old limit before removing it.
• Fee uncertainty: gas used is only one part of the fee. Base fee, priority fee, and blockspace demand still determine the ETH paid.
• Market risk: protocol repricing says nothing reliable about ETH's future price. Crypto assets are volatile; never risk funds you cannot afford to lose.

Frequently asked questions

Are EIP-8037 and EIP-8038 final?

The Ethereum Foundation describes them as scheduled for Glamsterdam, but the official EIP pages still show Review status as of September 16, 2026. Developers should test the current specifications and continue watching official fork and client announcements.

Will every Ethereum transaction cost more?

No. The changes target particular state-creation, access, and write operations. A transaction's result depends on its execution path and state. The network fee also depends on blockspace demand.

Do regular ETH holders need to do anything?

The Foundation says regular users need no special action; updated wallets and infrastructure should handle estimation. Never send ETH or reveal a seed phrase to “upgrade” for a fork.

Is raising the gas limit always the fix?

No. It fixes transactions whose top-level submitted limit is too low. It cannot necessarily repair fixed internal-call stipends, gas-dependent branching, or a presigned transaction that cannot be replaced.

Does the new state-gas dimension create a second fee token?

No. The transaction still pays gas in ETH under the normal fee market. State gas is an accounting dimension for resource limits, not a separate asset.

Bottom line

Glamsterdam gas repricing makes an old engineering lesson concrete: gas numbers are protocol parameters, not application APIs. EIP-8037 prices persistent growth separately; EIP-8038 updates the cost of reaching and changing existing state. The safest response is to remove brittle constants, improve estimation, test real state paths, and track the official specifications through activation.

This guide is educational, not financial advice. Verify current EIP and network status yourself, use development networks cautiously, and do your own research (DYOR/NFA).