GlamsterdamGlamsterdam Upgrade
UpcomingMajor network upgrade featuring Block-level Access Lists and ePBS. Named after the combination of "Amsterdam" (execution layer upgrade, named after the previous Devconnect location) and "Gloas" (consensus layer upgrade, named after a star).
Candidate EIPs are being fine-tuned, implemented, and tested on closed devnets. This process will determine which EIPs get Scheduled for Inclusion.
The planning timeline for Glamsterdam, showing the progression from headliner selection to final implementation decisions.
Fork Focus Discussion & Headliner Proposals
ACD calls focus on discussing Glamsterdam's high-level goals. Headliner champions present proposals.
Headliner Discussion & Finalization
ACD evaluates candidate headliners, solicits community feedback, and finalizes decisions.
Non-Headliner EIP Proposals
Non-headliner EIPs can now be proposed for inclusion in Glamsterdam.
Non-Headliner EIP CFI Decisions
ACDC and ACDE calls select which Proposed for Inclusion EIPs advance to Considered for Inclusion.
CFI → SFI EIP Decisions
As Glamsterdam devnets begin, final decisions on which CFI EIPs will be included in the upgrade's devnet.
Glamsterdam Proposals
Enshrined Proposer-Builder Separation
Proposes the decoupling of the consensus block from the execution payload, both in broadcast and validation. This feature enables L1 scaling by significantly changing the time required to both broadcast and executing the payload together with all the blob data, from the current ~2 seconds to aproximately ~9 seconds. It allows for a maximum portion of the slot to be spent in propagation large data.
Block-Level Access Lists
This introduces access lists at the block level rather than individual transactions, dramatically reducing gas costs for applications that access similar state and enabling new optimization patterns.
ETH transfers and burns emit a log
Make every ETH transfer—including from contracts and SELFDESTRUCT—emit an event log. Apps and explorers can track ETH movements uniformly, similar to ERC-20 transfers, improving deposit detection and reducing ad-hoc tracing.
Block Gas Accounting without Refunds
Closes a loophole where gas refunds let blocks pack extra work. Refunds still reduce user costs, but don't shrink the block's counted gas. Aligns block size with real EVM work and reduces worst-case block-size variance.
SLOTNUM opcode
Let contracts directly read the current slot number cheaply, removing timestamp math and reducing breakage if Ethereum's slot duration changes later.
Increase Maximum Contract Size
Raises limits so developers can deploy slightly larger contracts: up to 32KiB deployed code and 64KiB initcode after a fork. Existing contracts remain valid.
Increase Calldata Floor Cost
Increases the cost for data storage in transactions to help ensure Ethereum runs smoothly.
Increase Access List Cost
Adjusts transaction costs for access lists to balance gas fees and prevent block size inflation.
Backward compatible SWAPN, DUPN, EXCHANGE
Adds new instructions to increase the reachable elements of the stack.
State Creation Gas Cost Increase
Proposes to increase gas costs for state creation to mitigate state growth under higher throughput regimes.
Reduce intrinsic transaction gas
Changes base tx cost for more efficiency in cold/hot state management and improving ETH monetary functions. Lowering basic ETH tranfers to 6,000 gas and charging extra 25,000 for new account creation. Alternative to increasing block gas limit.
Revert creation in case of non-empty storage
Existing conditions to prevent deploying contract at address with existing data are insufficient, this ensures it cannot happen even in edge case scenarios. There are at least 28 contracts that were deployed with this issue.
Forward compatible consensus data structures
This EIP stabilizes Merkle tree indices for all consensus data, preventing coincidental verifier breakage when fields are added, removed, or list capacities change during Ethereum upgrades.
Compute Gas Cost Increase
Updates gas costs of all compute operatons to ensure they accurately reflect their computational workload.
eth/70 - partial block receipt lists
When Ethereum processes more transactions per block, the receipts can get too large to send in one network message. This lets nodes request receipts in smaller chunks, preventing sync failures as the network scales.
Deterministic Factory Predeploy
Enables developers to deploy smart contracts at identical addresses across EVM chains.
State-access gas cost update
Increases gas costs for accessing state data to ensure alignment with current performance.
Exclude slashed validators from proposing
After a slashing event, punished validators can still be scheduled to propose blocks, causing missed slots and slow recovery. This change simply skips slashed validators so healthy ones keep proposing and the chain keeps running.
Increase exit and consolidation churn
Raises limits on how many validators can activate, exit, or consolidate each epoch and separates consolidation churn, improving validator consolidation speed and easing deposit and exit queues while preserving a long weak-subjectivity period and existing security assumptions.
eth/72 - Sparse Blobpool
Ethereum nodes fully download only some blob transactions and sample the exact blob pieces the consensus layer cares about, cutting Execution Layer bandwidth roughly fourfold while keeping blob transactions moving.
Let exits use the consolidation queue
Changes how validator exits are queued by letting them share capacity with the consolidation queue. Removes an advantage for very large validators and lets more stakers exit or rebalance quickly without weakening security.
Cell-Level Deltas for Data Column Broadcast
Optimization for disseminating only previously unseen cells to the network for PeerDAS.
eth/71 - Block Access List Exchange
Allows Ethereum nodes to share block access lists over the network. These lists record which accounts and storage slots a block touched, enabling faster syncing and parallel transaction processing.
Remove SELFDESTRUCT Burn
Eliminate the remaining cases where SELFDESTRUCT burns ETH.
Cap deposit requests per block
Limits the number of deposit requests in an Execution Layer block to 8192.
Chunk-Based Code Merkleization
Breaks smart contract bytecode into fixed-size chunks stored in a Merkle Patricia Trie, reducing network bandwidth for block proof and resource consumption for real-time proving.
PAY opcode
The PAY opcode simply transfers ETH without executing code at recipient, making it more efficient, secure and compatible with account abstraction.
SSZ transactions
Moves Ethereum transactions from RLP to SSZ. This changes serialization and the block header's transactions_root, enabling more efficient proofs and future flexibility. Users should see no behavioral change.
SSZ receipts
Ethereum receipts, which record each transaction's outcome, currently use RLP and are hard to prove or verify. This proposal moves receipts to SSZ, enabling easier proofs, removing bloated logs bloom, and adding data to verify common receipt information.
Precompile Falcon512 generic verifier
Provide cost-efficient (ecrecover cost not MGas) verification of Falcon-512 signatures, one of the Post-Quantum Signatures being standardized by NIST.
Remove bloom filters
Bloom filters were supposed to provide log filters for applications but they do not work as originally intended. Under this EIP, the field is not entirely removed but needs to be empty. Applications should seek alternative and decentralized solution to fetching relevant logs.
Linear EVM memory limits
This proposal ties how much EVM memory a transaction can use directly to its gas. It simplifies memory pricing rules so each unit of gas corresponds to at most one byte of memory, making worst-case resource use easier to understand for operators and developers.
Trustless log and transaction index
Ethereum currently uses bloom filters in each block header to help search event logs, but they are inefficient today. This proposal replaces them with a new Merkle-based log index that uses moderate extra consensus data yet greatly reduces bandwidth and computation for finding events, especially for light clients and indexing services.
Reduce Block Latency
This reduces Ethereum's slot time from 12 seconds to 6 seconds, making Ethereum a better confirmation engine for apps and rollups. Everyone benefits: users get faster confirmations with better censorship resistance, DeFi gets more efficient trading with lower fees, stakers get lower reward variability, and nodes get better resource utilization with smoother bandwidth usage.
GAS2ETH opcode
EIP-7791 creates native fee mechanism for decentralized application by introducing a new GAS2ETH opcode that allows smart contracts to convert gas directly into ETH and send it to a specified address. It provides a new monetization mechanism for smart contract authors and public goods projects that scales with network usage. Instead of complex fee structures or token schemes, developers can charge gas (which users already understand) and receive proportional compensation during high network activity periods. The opcode takes a target address and gas amount, deducts the gas from the transaction, calculates the ETH value using the current gas price, and transfers that ETH to the specified address.
Conditional Transactions
Adds support for conditional transaction that is only valid at a chosen spot in a block, improving support for encrypted mempools.
Fork-choice enforced Inclusion Lists (FOCIL)
FOCIL empowers multiple validators to mandate the inclusion of specific transactions in each block, thereby improving the network's censorship resistance properties.
SETDELEGATE instruction
Adds a new instruction for upgradeable, lightweight contract clones via EIP-7702 delegation. This is similar to upgradable proxy contracts but enabled natively on protocol level, therfore cutting gas and complexity.
Max blob flag for local builders
Lets node operators set a cap on how many blob-carrying transactions their local builder includes in a block, helping bandwidth-constrained setups avoid overfilling blocks with blobs.
Remove Initcode Size Limit
This removes the 49,152-byte limit on initialization code (initcode) that was introduced by EIP-3860. The problem this solves is that the current limit makes it unnecessarily difficult to deploy large, complex smart contracts that need to create multiple sub-contracts in a single transaction. For example, if you want to deploy a sophisticated DeFi protocol that consists of several interconnected contracts, you might hit the initcode limit even though each final contract stays under the 24KB deployed code limit (EIP-170). This forces developers to split deployments across multiple transactions, which is more expensive, less efficient, and breaks the clean abstractions that high-level programming languages try to provide. By removing this artificial limit, the EIP allows for more flexible deployment patterns while still maintaining security through existing gas costs that scale with initcode size. The per-block gas limit already naturally restricts initcode to reasonable sizes (around 16MB at current gas limits), making the 49KB cap redundant. This change is fully backward compatible and only removes restrictions without changing how contracts work.
Meter Contract Code Size And Increase Limit
Increases the contract code size limit from 24KB to 256KB and introduces gas metering for larger contracts. This will enable developers to deploy larger files and applications in a single contract instead of more complex multi contract architecture.
Linear, Page-Based Memory Costing
Linearizes EVM memory with 4KB pages: 100-gas allocation, 6-gas thrash, 64MB cap. Contracts that hit quadratic expansion limits finish with the same logic but steadier gas usage, allowing for more efficient memory management and predicatble gas costs.
Secondary Signature Algorithms
Creates a standardized way for new transaction-level signature algorithms to be added, which allows easier migration and higher interoperability with current systems.
Genesis File Format
Standardizes genesis file structure to streamline compatibility across Ethereum clients, aiding smoother network launches.
Hard Limits for Transient Storage
Makes transient storage cheaper and sets a hard cap on how much can be used per transaction. This reduces gas for common patterns while protecting nodes from excessive memory use.
Warm Account Write Metering
Changes gas rules so once an account is updated in a transaction, later updates to it are cheaper, aligning fees with actual state-root work and reducing the penalty for repeated ETH transfers or future value-transfer opcodes.
Call and Return Opcodes for the EVM
Introduces instructions to call and return from subroutines, which are missing from the EVM. This lets compilers generate code with static control flow, which allows for more performant clients and quadradictally more efficient static analysis tools
Multidimensional Gas Metering
Improves resource allocation by allowing separate metering for computation, data access, and storage, enhancing Ethereum's ability to handle resource limits more effectively.
Static relative jumps and calls for the EVM
Adds five new EVM jump/call instructions that point to nearby code using a small offset instead of a pushed address, making contracts cheaper to run and easier for clients and tools to verify after Glamsterdam.
P256 algorithm support
Adds P256 signature support to the EIP-7932 algorithm registry to allow use with the registry interface.
Size-Based Storage Gas Pricing
Adjusts gas costs for SSTORE operations based on how much data a contract holds, incentivizing efficient storage management.
Precompile for ML-DSA signature verification
Adds two precompiles for signature verification that are safe against Quantum Computer analysis. One is an NIST standard FIPS-204 whereas the other replaces the XOF with Keccak, which is more accessible to EVM implementation.
Milli-gas for High-precision Gas Metering
Counts gas in thousandths (milli-gas) during EVM execution for finer precision, then rounds to normal gas at transaction end. Fees and limits stay the same, so users and apps shouldn't notice changes.
Inter-Block Temporal Locality Gas Discounts
Ethereum clients already cache recently used state, so touching the same contracts again soon is cheaper in practice. This EIP updates gas costs to reflect that reality: if an account or storage slot was accessed in the last few blocks, the first access in a new transaction costs less gas. Nothing else about how transactions work changes.
Contract Bytecode Deduplication Discount
If you deploy a contract that's exactly the same as one that already exists and you include that existing contract's address in your transaction's access list, you don't pay the per-byte code deposit again—the new contract just points to the already-stored code.
Gas Units Rebase for High-precision Metering
This proposal rebases Ethereum's gas unit by a factor of 1,000 to enable high-precision metering without fractional gas. All gas-related parameters and variables are increased by that factor.
Add sweep withdrawal fee for 0x01 validators
Adds a small 0.05% fee when old-style 0x01 validators auto-withdraw extra balance, keeping consolidation and costs fair.
Neutral effective balance design
Makes staking treat 'skimmed' and 'compounding' validators the same by tweaking effective balance rules, so operators can consolidate without losing yield.
Prevent using consolidations as withdrawals
Prevents consolidation requests that would push the target validator's effective balance above the maximum.
Preimage retention
Have nodes temporarily keep the original addresses and storage keys used before the Verge, so Ethereum can switch to Verkle trees smoothly.
Raise gas costs of hash functions
Increase gas for hashing to better match real costs, prevent hash-heavy block abuse, and keep Ethereum verification practical and decentralized.
Pureth Meta
This enables Ethereum nodes to provide cryptographic proofs with their responses, eliminating the need to trust RPC providers. Users can verify that data from any source is authentic without running their own full node.
Unified multidimensional fee market
Simplifies fee management for transactions by allowing users to set one budget for various resources like storage and computation.
EVM Object Format (EOFv1) Meta
This introduces a new container format for EVM bytecode that enables code versioning, removes complex jump analysis, and paves the way for new execution environments like RISC-V and EVM64 within the same contract. This EIP was Declined for Inclusion from Fusaka on [April 28th](https://blog.ethereum.org/2025/04/29/checkpoint-2#eof) due to a lack of consensus on implementation details and the resulting potential slowdown of shipping PeerDAS. It has been re-proposed as a headlining feature in Glamsterdam with multiple variants to address community concerns.
Delayed execution
Lets validators attest before execution by deferring execution outputs, improving throughput headroom.
EVM64 - 64-bit mode EVM opcodes
This is the core EIP of the EVM64 collection, introducing 64-bit arithmetic operations to the EVM. The full EVM64 suite includes multiple EIPs enabling much more efficient mathematical computations by adding 64-bit operations alongside existing 256-bit ones.
Available Attestation
This is a comprehensive solution to eliminate all known reorganization attacks on Ethereum. Instead of fixing attacks one-by-one, Available Attestation redesigns how consensus works to make reorg attacks fundamentally impossible.