Ethereum’s Glamsterdam upgrade: what changes for users, builders and DeFi

Ethereum’s next major upgrade is moving into its final development phase. For users, apps and infrastructure teams, Glamsterdam could make Ethereum easier to index, faster to process and better prepared for future scaling.

What if Ethereum could make DeFi infrastructure faster, easier to read and more reliable without changing what users do?

That is the idea behind Glamsterdam, Ethereum’s next major hard fork and one of its biggest protocol upgrades since the Merge.

Now in late-stage development, Glamsterdam is being tested on devnets with its planned EIPs before moving to public testnets. The upcoming upgrade combines several protocol changes that could affect how Ethereum blocks are built, how ETH transfers are tracked, how clients process state and how much logic smart contracts can contain.

Better block construction can affect MEV. Better state access can improve performance. Native ETH transfer logs can make indexing easier. Larger contract code limits can give developers more room to build advanced on-chain logic.

ETH transfers become easier to track

According to Kirill Kuznetsov, Senior Solution Architect at 1inch, some of Glamsterdam’s most important changes are highly practical. One of the less flashy but highly useful changes is that native ETH transfers are expected to emit logs.

Until now, tracking token transfers has been much easier than tracking ETH movement. ERC-20 transfers emit events, which backend systems can index directly. Native ETH transfers, by contrast, often require deeper tracing of internal calls to identify where value moved.

Kirill says this has long been a pain point for teams building transaction histories, portfolio views and analytics tools.

“Previously, tracking native ETH transfers was much harder than tracking token transfers,” he explains. “Token transfers can be followed through events, but native ETH transfers often required tracing internal calls and looking for value-transfer operations.”

With Glamsterdam, native ETH transfers should also emit logs. That makes life easier for backend applications, indexers, wallets and explorers.

“For backend apps, this will make indexing native ETH transfers much simpler,” Kirill says. “I think this is a great change.”

For users, the change may not be visible directly. But it can improve the infrastructure around the user experience: cleaner histories, better accounting, easier portfolio tracking and fewer edge cases around smart contract wallets.

A more native model for block building

Another major part of Glamsterdam is enshrined Proposer-Builder Separation, or ePBS.

Today, block construction and block proposal are separated largely through offchain infrastructure. Validators can outsource block building to specialized builders, but this often relies on relay services between the builder and proposer. Glamsterdam aims to bring more of that process into the Ethereum protocol itself.

Kirill says the key benefit is removing some of the trusted middle layer from the current model.

“The cool thing about Proposer-Builder Separation is that it removes third-party relay services,” he says. “Builder-proposer separation can work without a man-in-the-middle.”

In practical terms, that means the proposer should be more reliably paid by the builder, while the builder’s payload becomes harder to manipulate or replace in ways that break the expected flow. According to Kirill, this can make MEV “more honest.”

That does not mean MEV will totally disappear. It means that Ethereum can reduce reliance on trusted intermediaries and make the block-building process more transparent and protocol-native.

There is also a performance angle, Kirill notes, as removing the execution payload from the consensus block should help blocks propagate faster across the network. Faster propagation helps nodes synchronize more efficiently, which matters as Ethereum continues to scale.

Block-level access lists to enable more parallel processing

Glamsterdam also includes Block-Level Access Lists, one of the upgrade’s most technically important changes.

Access lists already exist at the transaction level, but they are optional and limited. Glamsterdam moves the concept to the block level.

That means a block will carry information about which accounts and storage slots are touched, where state changes happen and what data changes from one value to another. Kirill describes this as the beginning of a larger shift toward parallelization on Ethereum.

This is important because Ethereum execution has historically been constrained by the need to process transactions in order. If clients know more about the state a block will touch, they can preload and process data more efficiently.

That may not instantly make Ethereum fully parallel, but it creates a foundation for more parallel execution, faster validation and better client performance over time.

For DeFi protocols, wallets and infrastructure providers, this matters because the user experience depends on the performance of the underlying chain. Faster and more predictable execution can help the ecosystem support more activity without simply pushing complexity onto users.

More room for complex smart contracts

Another change Kirill highlights is an increase in the maximum contract bytecode size.

This is especially relevant for developers building advanced protocols, routing systems, account abstraction flows and other complex on-chain logic.

“Contract bytecode size is being increased significantly,” Kirill says. “That means more logic can fit into a contract, and developers will be able to build more complex contracts.”

For DeFi, this matters because protocols often hit practical limits not only in gas costs but also in how much logic can be deployed cleanly and safely. Increasing the code size limit gives developers more design space.

Gas repricing could change Ethereum economics

Glamsterdam is also expected to include gas repricing changes. The broad direction is clear: high-level computation should become cheaper, while state-related operations become more expensive.

That reflects one of Ethereum’s long-term constraints. Computation is not always the scarcest resource. State growth - the long-term burden of storing and accessing data across the network - is one of the biggest scaling challenges.

For users and builders, this means some actions may become cheaper while others may become more expensive. The exact impact will depend on the type of transaction, the contract design and how much state the operation creates or touches.

For developers, the message is simple: gas assumptions may need to be reviewed. Protocols, wallets and backend systems should test how their transaction flows behave under the new pricing model.

Why Glamsterdam matters for DeFi

Glamsterdam is not a consumer-facing upgrade in the way a new app feature is. Most users will not wake up and see a new Ethereum interface. But the changes can still affect the entire DeFi stack.

Native ETH transfer logs can make indexing cleaner. ePBS can reduce reliance on trusted relays and make block building more protocol-native. Block-level access lists can help clients process state more efficiently. Larger contract limits can give builders more room. Gas repricing can push developers toward more sustainable resource usage.

Together, these changes point in one direction: Ethereum is preparing for more activity, more complex applications and more scalable infrastructure.

Swap tokens on Ethereum through 1inch.