Ethereum changes through EIPs

An EIP (Ethereum Improvement Proposal) is a public proposal to change Ethereum. The network only changes once a proposal has been discussed on core developer calls and included in a hard fork.

EIP explainers

• EIP-8411 Fast propagation of execution payloads (Fast Execution Payload Broadcast) — This changes the way EIP-7732 sends the execution payload as a single message into sending it split into 64 chunks. The builder puts the Merkle root of the chunk set into the bid so that each chunk can be verified separately.
• EIP-8383 Shorter consensus layer block retention period (Reduce CL Block Retention Window) — Reduces the minimum retention period for old beacon blocks that consensus layer nodes must serve to peers from 33,024 epochs to 8,192 epochs (about 36 days). It changes a single configuration value without a hard fork.
• EIP-8379 Top-up sync: consensus-layer-led execution-layer sync (Top-up Sync) — Adds Engine API methods that let the consensus client query the execution client's block head and execution head, and adds response values that distinguish the no-state case from the no-block-history case, so that the consensus client can directly lead the execution client's block sync.
• EIP-8374 Keep warm access after a revert (Persist Warm Access Sets Across Reverts) — When a call fails and is reverted, the warm status of the addresses and storage keys read inside it is not erased. If the same transaction reads them again, it pays the cheap warm cost instead of the expensive cold cost.
• EIP-8372 Normalized State Gas Limit (Normalized state gas limit) — Gives the state gas of EIP-8037 its own limit, separate from the block limit, and normalizes its usage when computing block gas used. At the fork, the cost per state byte (CPSB) and the limit ratio are calibrated once to the demand estimate.
• EIP-8371 RowDAS, Distributed Blob Reconstruction (RowDAS - Distributed Blob Reconstruction) — In PeerDAS, blob reconstruction work concentrates on supernodes. RowDAS spreads it across the whole network through row-based gossip topics. Every node takes part in reconstruction, which greatly reduces the burden on supernodes and creates a recovery path that works without them.
• EIP-8369 FOCIL eligibility VOPS profiles (VOPS Profiles for FOCIL Eligibility) — An informational EIP that describes two eligibility criteria (VOPS profiles) that determine which transactions FOCIL, a censorship resistance mechanism, will force to be included and protect from omission.
• EIP-8368 CPSB recalibration for the new gas limit (CPSB Recalibration for New Gas Limit) — A proposal to recompute the cost per state byte (CPSB) introduced by EIP-8037 for a higher block gas limit. The new reference limit and values are placeholder drafts that are not yet decided.
• EIP-8365 Ban on registering new 0x00 validators (Disallow new 0x00 validators) — Deposits that create new validators with 0x00 (BLS) withdrawal credentials are no longer processed. Existing 0x00 validators are left as they are, and the path for converting them to 0x01 stays open.
• EIP-8363 Declining issuance burn (Tapered Issuance Burn) — As more ETH is staked, a set share of validator rewards is burned to reduce issuance. At the point where half of all ETH is staked, the burn rate reaches 100%, and the incentive to issue more for additional staking disappears.
• EIP-8360 TCREATE opcode (TCREATE Opcode) — Adds TCREATE, a new EVM instruction that creates a temporary contract that exists only within a single transaction. When the transaction ends, the code and nonce are discarded and only the balance remains.
• EIP-8358 Net gas metering for account changes (Net Gas Metering for Account Changes) — Changes the transfer cost rules for sending ether within one transaction so that each account is charged only the first time it changes, already changed accounts are cheap, and accounts that return to their original balance receive a gas refund.
• EIP-8355 ML-DSA signature verification precompiles (Precompiles for ML-DSA Verification) — Adds three precompiles at addresses 0x12, 0x13 and 0x14 that verify the post-quantum signature scheme ML-DSA (FIPS 204). Given the public key, signature and message concatenated without length prefixes, they return a 32-byte validity result.
• EIP-8333 Aligning checkpoints to the epoch boundary block (Align Checkpoint with Epoch Boundary Block) — The block that the FFG checkpoint of epoch N points to moves from the first block of epoch N to the block just before it (the boundary block). The checkpoint's epoch number stays the same, and only which block it points to changes.
• EIP-8321 Hash-chain RANDAO (Hash-Chain RANDAO) — Replaces RANDAO's BLS-signature-based randomness contribution with a quantum-resistant hash-chain commit-reveal scheme. A validator registers a hash chain in advance and reveals it one step backward at each block proposal.
• EIP-8304 Trustless log and transaction index (Trustless log and transaction index) — Builds a log and transaction index table for each block and stores its root hash in a system contract. Anyone can verify with a proof that log and transaction lookup results are correct.
• EIP-8298 SETCODEFROM code reuse instruction (SETCODEFROM Code Reuse Instruction) — Adds SETCODEFROM, an EVM instruction that copies the code hash of an already deployed contract to the current account. It removes the cost of redeploying the same code and also opens a path for regular accounts to operate through code alone, without an ECDSA key.
• EIP-8297 Zoned Binary State Tree (Partitioned Binary Tree) — Replaces Ethereum's state storage structure, the hexary Merkle Patricia Trie, with a single binary tree. The first byte of a key distinguishes the account header, code, and storage zones, and contract code is also split into chunks and placed in the tree.
• EIP-8288 Mempool signature and proof aggregation (In-mempool signature and proof aggregation) — Adds an EIP-8141 frame mode that, instead of putting post-quantum signatures and STARK proofs into the block as they are, bundles them in the mempool into one recursive STARK and carries it in the block header.
• EIP-8282 Builder execution requests (Builder Execution Requests) — Separates builder registration (deposit) and exit for EIP-7732 from the validator process, handling them with two dedicated predeploy contracts on the EIP-7685 request bus and two new request types (0x03, 0x04).
• EIP-8279 Block access list byte floor (Block Access List Byte Floor) — Counts the bytes added to the block access list (BAL) during execution for each transaction and adds them to the EIP-7623 floor price at 64 gas per byte. The worst-case size of a 60M gas block drops from about 1.55MiB to about 0.89MiB.
• EIP-8272 Recent roots for frame transactions (Recent Roots for Frame Transactions) — Lets EIP-8141 frame transactions check, during public mempool validation, a Merkle root that an app recorded recently. One standard contract stores per-slot roots, and a dedicated VERIFY frame checks them.
• EIP-8268 Add storage root to the block access list (Storage Roots in Block Access Lists) — Includes the post-block-execution storage trie root for each state-changed account in the EIP-7928 block access list (BAL), so that nodes holding only part of the state can also verify a block's state root.
• EIP-8261 Gas limit schedule (Gas Limit Schedule) — Recommends putting an epoch-based gas limit schedule in the consensus layer config file, so that validators' default gas limit and recommended maximum change automatically at set times. It does not change consensus rules.
• EIP-8253 Raising the nonce of nonce-0 storage accounts (Bump nonce of zero-nonce storage accounts) — At the start of the fork block, raises to 1 the nonce of 28 mainnet accounts that have no code and nonce 0 but non-empty storage. This prevents a new contract from being created at these addresses under the EIP-684 rule alone.
• EIP-8252 Execution Layer Reorg State Retention Period (Execution-Layer Reorg State Retention Window) — An informational proposal that requires execution layer clients to keep enough data to rebuild the state of every block from the last 262,144 blocks (about 36.4 days). The goal is to handle a deep chain reorg without syncing from scratch.
• EIP-8250 Keyed nonces for frame transactions (Keyed Nonces for Frame Transactions) — Replaces the single nonce of a frame transaction with a list of nonce keys and one sequence number. Transactions with non-overlapping keys do not wait for each other's ordering, so privacy apps where many users share one sender address are not blocked.
• EIP-8243 Source-stage attestation batching (Batching Attestations at Source) — Lets an operator running multiple validators assigned to the same committee gossip one pre-aggregated batch attestation instead of N individual attestations. The on-chain format does not change.
• EIP-8237 Independent sync for the consensus and execution layers (Independent CL/EL Sync) — Replaces the execution_requests_root in the bid with partial_header_hash, a SHA256 accumulator hash, so the consensus layer can do range sync without downloading execution payloads.
• EIP-8219 Checked arithmetic opcodes (Checked Arithmetic Opcodes) — Adds four new EVM instructions (SAFEADD, SAFESUB, SAFEMUL, SAFEDIV) that automatically revert execution on overflow or division by zero in addition, subtraction, multiplication and division.
• EIP-8205 Withdrawal credentials pre-registration (Withdrawal credentials preregistration) — Adds a mechanism for the holder of a validator key to bind withdrawal credentials ahead of the deposit. The consensus layer checks this when processing the deposit, which prevents an attack in delegated staking where someone else deposits first and hijacks the withdrawal address.
• EIP-8200 Moving precompiles to the EVM (EVMification) — Replaces three precompiles, RIPEMD-160 (0x03), MODEXP (0x05), and BLAKE2f (0x09), with ordinary EVM bytecode that does the same job. Addresses and functionality stay the same; only the internal implementation changes.
• EIP-8198 Quick Slots: slot time from 12 seconds to 10 seconds (Quick Slots) — Replaces the slot time, currently a constant fixed in code, with a per-epoch schedule (SLOT_DURATION_SCHEDULE), and uses that mechanism to cut the block interval from 12 seconds to 10 seconds. Rewards, penalties and the blob retention period stay the same in real time.
• EIP-8189 snap/2: BAL-based state healing (snap/2 - BAL-Based State Healing) — Upgrades the snap sync protocol to snap/2 and replaces the healing phase, which fetched Merkle trie nodes one by one to reconcile state, with downloading and applying block access lists (BALs).
• EIP-8188 Last-written block of accounts and slots (Last-Written Block for Accounts and Slots) — Records the number of the block in which each account and storage slot was last modified (last_written_block) as consensus state. It is updated only on writes, gas costs do not change, and it becomes a signal that clients can use for storage tiering.
• EIP-8182 Private ETH and ERC-20 transfers (Private ETH and ERC-20 Transfers) — Installs a shielded pool system contract managed directly by the protocol, so that ETH and ERC-20 tokens can be sent privately. It adds no new instructions or transaction types.
• EIP-8163 Reserving the EXTENSION (0xae) opcode (Reserve `EXTENSION (0xae)` opcode) — It reserves the opcode EXTENSION (0xae), which will never become a valid instruction on Ethereum L1, so that other EVM chains can use it as an extension prefix to add new instructions safely.
• EIP-8151 ecRecover restricted by account code (Account Code Restricted ecRecover) — The ecRecover precompile, which recovers an address from a signature, checks the code of the recovered account. It returns the address only when the code is empty or is an EIP-7702 delegation designator, and otherwise returns the same empty output as a failed signature.
• EIP-8148 Validator-customized sweep threshold (Custom sweep threshold for validators) — Lets validators using compounding withdrawal credentials (0x02) set for themselves, between 32 ETH and 2,048 ETH, the balance above which rewards are automatically swept to the withdrawal address.
• EIP-8146 Block access list sidecar (Block Access List Sidecars) — Separates the block access list (BAL) from the execution payload and propagates it first in a dedicated sidecar. The block size on the critical propagation path is halved, and execution clients can pre-read state before the payload arrives.
• EIP-8142 Block-in-Blobs (Block-in-Blobs (BiB)) — A proposal to put transactions and the block access list into blobs and carry them in the same beacon block, so that execution data is always published even in an era when blocks are verified with zkEVM proofs.
• EIP-8141 Frame transactions (Frame Transaction) — Adds a new transaction type (0x06) that splits a transaction into multiple frames (contract calls) and lets account code decide verification, fee payment, and execution directly. It is a proposal to build account abstraction natively into the protocol.
• EIP-8136 Cell-level delta for data column propagation (Cell-Level Deltas for Data Column Broadcast) — A networking optimization in PeerDAS where, instead of exchanging whole blob data columns, nodes pick out and exchange only the cells they are missing. It can be rolled out gradually client by client without a hard fork.
• EIP-8135 Hard fork meta: BPO2 (Hardfork Meta - BPO2) — A meta EIP recording the activation time and changed values of BPO2, Ethereum mainnet's second Blob-Parameter-Only (BPO) upgrade. The blob target per block increased from 10 to 14, and the maximum increased from 15 to 21.
• EIP-8134 Hard fork meta: BPO1 (Hardfork Meta - BPO1) — A meta EIP that officially records the activation time, blob target and maximum, and fee parameters of BPO1, Ethereum mainnet's first Blob-Parameter-Only (BPO) upgrade.
• EIP-8131 Unified transaction content floor price (Unified Transaction Content Floor) — Sets a minimum fee of 64 gas per byte on every byte a user fills in a transaction (calldata, access list, EIP-7702 authorizations, blob hashes). This arithmetically bounds the worst-case amount of data that fits in one block.
• EIP-8130 Keystore Accounts (Keystore Accounts) — Lets each account register multiple signing keys (actors) in an on-chain keystore and set a permission scope and expiry per key. The same permission setup works across any transaction format.
• EIP-8116 Replacing the cumulative gas field in receipts (Replace cumulative receipt fields) — The gas field of the receipt stored in the block is changed from the running total since the start of the block (cumulativeGasUsed) to the amount that transaction used (gasUsed). The log index (logIndex) in RPC responses is also changed from a block-based index to a receipt-based index.
• EIP-8115 Batch settlement of priority fees at the end of the block (Batch priority fees at end of block) — Priority fees that used to be paid out right after each transaction finishes are instead summed up after all transactions in the block have finished and paid out once.
• EIP-8094 Blob-aware mempool (eth/vhash) (eth/vhash - Blob-Aware Mempool) — Changes blob transactions to propagate first without the blob body (sidecar), with the body requested separately by blob hash (vhash). When only the fee is changed in a replacement (RBF), the same blobs are no longer downloaded again.
• EIP-8081 Hegotá Hardfork Meta (Hardfork Meta - Hegotá) — A meta EIP that compiles the official list of which EIPs go into the next network upgrade, Hegotá. It records them in four stages: Scheduled, Considered, Proposed and Declined.
• EIP-8077 Add sender and nonce to transaction announcements (eth/XX - announce transactions with nonce) — Messages that nodes use to announce new transactions to each other also carry the address and nonce of the sending account. This is a mempool communication improvement that lets the receiving node choose more intelligently which transactions to fetch first.
• EIP-8070 eth/72 sparse blobpool (eth/72 - Sparse Blobpool) — Changes the execution layer blobpool, where every node downloads the full blob data, so that a node receives the full data only with 15% probability and otherwise samples only the same assigned pieces as the consensus layer, cutting average bandwidth to about a quarter.
• EIP-8061 Higher exit and consolidation processing limit (Increase Exit and Consolidation Churn) — Increases the amount that validator exits and the consolidation queue process each epoch. The exit limit loses its cap and becomes proportional to total stake, and consolidation gets its own dedicated limit. The activation cap stays as it is.
• EIP-8058 Gas discount for duplicate contract deployment (Contract Bytecode Deduplication Discount) — A proposal that waives the code storage gas when redeploying code identical to a contract already on the chain, if the existing contract's address is put in the transaction's access list.
• EIP-8038 State access gas cost update (State-Access Gas Cost Update) — Raises the gas cost of instructions that read and write accounts or storage slots. As Ethereum state has grown and these operations have become slower, the costs are repriced by splitting them into three components: access, write and creation.
• EIP-8037 Increase in gas cost for state creation (State Creation Gas Cost Increase) — Raises and unifies the gas cost of operations that grow Ethereum state, such as new accounts, new storage slots, and contract code, to a standard of 1530 gas per byte of state, and counts this cost separately from execution gas.
• EIP-8025 Optional execution proofs (Optional Execution Proofs) — An optional feature that lets consensus layer nodes confirm validity through cryptographic proofs, without re-executing the execution payload themselves. Participation is voluntary and the consensus rules do not change.
• EIP-8015 Removal of Deposit and Eth1 Data Fields (Remove `deposit` and `eth1data` fields) — Removes the old deposit fields and the Eth1 data voting mechanism that are no longer used from the beacon block body and beacon state. This change cleans up what was left over after EIP-6110 moved deposit processing to the execution layer.
• EIP-7997 Deterministic Factory Contract (Deterministic Factory Contract) — Makes it an official requirement that the widely used CREATE2 factory exists at address 0x4e59b44847b379578588920cA78FbF26c0B4956C. As a result, contracts can be deployed to the same address on any EVM chain.
• EIP-7979 EVM call and return instructions (Call and Return Opcodes for the EVM) — Adds three instructions to the EVM for subroutine calls and returns: CALLSUB, CALLDEST and RETURNSUB. It makes function calls, which were previously imitated with dynamic jumps, explicit, saving code and gas and making analysis easier.
• EIP-7973 Warm account write charging (Warm Account Write Metering) — A gas repricing that discounts the write cost from the second time the same account is modified within one transaction, because the state root update happens only once anyway.
• EIP-7971 Transient storage gas reduction and hard limit (Hard Limits for Transient Storage) — Lowers the gas cost of the transient storage opcodes TLOAD and TSTORE from 100 to 5 and 12 respectively, and limits the number of slots usable in one transaction to 131072 to prevent resource exhaustion attacks.
• EIP-7954 Raise maximum contract size to 64KiB (Increase Maximum Contract Size) — Raises the maximum size of contract code that can be deployed on Ethereum from 24KiB to 64KiB, and the maximum size of the initialization code (initcode) executed when creating a contract from 48KiB to 128KiB.
• EIP-7951 secp256r1 signature verification precompile (Precompile for secp256r1 Curve Support) — Adds P256VERIFY, a precompile at address 0x100 that verifies digital signatures on the secp256r1 (P-256) curve used by smartphone secure chips and WebAuthn devices. It is a specification that fixes the security flaws of RIP-7212, which is deployed on L2s.
• EIP-7939 Count Leading Zeros (CLZ) Opcode (Count leading zeros (CLZ) opcode) — Adds a new EVM opcode, CLZ (0x1e), that counts in one step how many consecutive 0 bits lead a 256-bit value. The cost is 5 gas.
• EIP-7938 Exponential gas limit increase (Exponential Gas Limit Increase) — A proposal to change client default settings so the gas limit rises exponentially each epoch, growing about 100 times over four years (from 50 million to 5 billion). It does not change the protocol consensus rules.
• EIP-7935 Default gas limit raised to 60M (Set default gas limit to 60M) — Recommends that execution layer clients raise the gas limit value in their default configuration from 36M to 60M. This is an informational proposal to apply the change in time for the Fusaka hard fork launch.
• EIP-7934 RLP execution block size cap (RLP Execution Block Size Limit) — Sets a protocol-level cap on the size of a block when RLP-encoded. Blocks larger than the total 10 MiB limit minus the 2 MiB beacon block share are treated as invalid.
• EIP-7928 Block-level access lists (Block-Level Access Lists) — Makes a block access list (BAL) mandatory, containing every account and storage slot the block accessed along with post-execution values, and puts its hash in the block header so that disk reads and transaction validation can be processed in parallel.
• EIP-7923 Linear page-based memory pricing (Linear, Page-Based Memory Costing) — Changes EVM memory cost from the current quadratic formula to linear pricing per page (4096 bytes). Each page touched for the first time costs 100 gas, and a hard cap of 64 MB applies to the whole transaction.
• EIP-7918 Introduce an execution cost floor for blob fees (Blob base fee bounded by execution cost) — Sets a minimum price so that the price of one blob never falls below the price of a fixed amount of execution gas. This prevents the blob fee from falling to 1 wei and losing its price adjustment function.
• EIP-7917 Deterministic proposer lookahead (Deterministic proposer lookahead) — At the start of each epoch, the list of block proposers for the current and next epochs is precomputed and stored in the beacon state. Who will propose blocks in the next epoch is fixed in advance.
• EIP-7910 The eth_config JSON-RPC method (eth_config JSON-RPC Method) — Adds the eth_config RPC method, through which a node reports as JSON the configuration values of the fork currently active, the next fork, and the last configured fork. This allows checking in advance whether client configuration is correct before a hard fork.
• EIP-7907 Contract code size gas charge (Meter Contract Code Size) — When loading contract code larger than 24KB, an extra 2 gas is charged per 32 bytes of the excess. This proposal makes callers pay gas in proportion to the work that contracts growing up to 64KB under EIP-7954 impose on nodes.
• EIP-7906 Verifying transaction results with state-change opcodes (Transaction Assertions via State Diff Opcode) — A read-only check stage (the ASSERT frame) is attached at the very end of the transaction. Inside it, the new opcodes TXTRACE and EVENTDATACOPY read the balance, storage, code and nonce changes and the events the transaction left behind, and if a condition is violated, the execution result is reverted.
• EIP-7892 Blob-parameter-only hard fork (Blob Parameter Only Hardforks) — Defines a lightweight hard fork (BPO fork) that changes only the three numbers determining blob capacity (target, max, baseFeeUpdateFraction) via the configuration file. Blob capacity can be raised frequently and in small increments without modifying client code.
• EIP-7886 Delayed Execution (Delayed execution) — Separates block validation from execution so that a validator can check and attest to a block's validity without executing its transactions. The execution result is verified in the next block.
• EIP-7883 ModExp gas cost increase (ModExp Gas Cost Increase) — Changes the gas formula of the ModExp precompile, which computes modular exponentiation, raising the minimum cost from 200 to 500 and the general cost by about 3x.
• EIP-7870 Recommended node hardware and bandwidth specifications (Hardware and Bandwidth Recommendations) — A guidance document that lays out, by role, the storage, memory, CPU and internet connection speed that are good for an Ethereum full node and validator (attester, local block builder) to have. It is an Informational EIP that does not change the protocol.
• EIP-7862 Delayed state root (Delayed State Root) — A proposal that places the previous block's post-state root in the block header instead of the block's own state root, decoupling state root computation from block validation.
• EIP-7851 Code-controlled EOA delegation (Code-Controlled EOA Delegation) — Lets an EOA delegated through EIP-7702 change its delegation target directly from wallet code and permanently disable the authority of its original private key (ECDSA). Adds a new delegation prefix 0xef0101 and the SETSELFDELEGATE instruction.
• EIP-7840 Adding a blob schedule to the execution client configuration (Add blob schedule to EL config files) — Adds a blobSchedule entry to the execution client configuration file, so that per-fork target blob count per block (target), maximum count (max), and the fee update coefficient (baseFeeUpdateFraction) can be specified.
• EIP-7825 Transaction Gas Limit Cap (Transaction Gas Limit Cap) — Limits the gas a single transaction can use to 16,777,216 (2^24) at the protocol level. This cap applies regardless of the block gas limit.
• EIP-7823 MODEXP Input Cap (Set upper bounds for MODEXP) — Limits the base, exponent, and modulus input lengths of the MODEXP precompile to at most 8192 bits (1024 bytes) each. A call that exceeds the limit is treated as an error and consumes all gas.
• EIP-7819 SETDELEGATE opcode (SETDELEGATE instruction) — Adds a new EVM opcode, SETDELEGATE (0xf6), that lets a contract create and change EIP-7702-style delegation designators directly. It reuses the same code through a 23-byte delegation instead of clones or proxies.
• EIP-7807 SSZ execution block (SSZ execution blocks) — Changes the serialization of execution blocks from RLP to SSZ, which the consensus layer uses, and computes the block hash as the SSZ hash_tree_root. Individual transactions, receipts, withdrawal entries and the state trie are left as they are.
• EIP-7805 Inclusion lists enforced by fork choice (Fork-choice enforced Inclusion Lists (FOCIL)) — A 16-validator committee each slot builds an inclusion list from public mempool transactions, and attesters do not vote for blocks that leave those transactions out, so transactions get included on time without censorship.
• EIP-7782 Reducing block latency (Reduce Block Latency) — Cuts Ethereum's slot time from 12 seconds to 6 seconds. Block and blob sizes stay the same and only the interval between blocks is halved, which halves the confirmation latency and the time to finality.
• EIP-7779 Interoperable delegated accounts (Interoperable Delegated Accounts) — Defines a standard interface for looking up account information and storage bases and for cleaning up before leaving, so that an EOA delegated to a smart account via EIP-7702 can re-delegate without storage collisions when it moves wallets.
• EIP-7773 Glamsterdam hard fork meta (Hardfork Meta - Glamsterdam) — A meta EIP that collects the list of EIPs going into the Glamsterdam network upgrade in a single document. It covers the 18 changes confirmed for inclusion, the networking and informational EIPs, and the testnet activation schedule.
• EIP-7745 Trustless log and transaction index (Trustless log and transaction index) — Replaces the 2048-bit bloom filter in the block header with a new index structure that places all logs, transactions, and blocks in a single linear index space, which can be verified and searched using Merkle proofs.
• EIP-7732 Enshrined Proposer-Builder Separation (Enshrined Proposer-Builder Separation) — Separates the execution payload from the beacon block, splitting the block into a consensus part and an execution part, and lets the proposer pick a builder's bid inside the protocol and hand block production to that builder. This is proposer-builder separation without a trusted intermediary.
• EIP-7723 Network upgrade inclusion stages (Network Upgrade Inclusion Stages) — A meta EIP that formally defines the five stages (Proposed for Inclusion, Considered for Inclusion, Scheduled for Inclusion, Declined for Inclusion, Included) that a core EIP goes through to be included in a network upgrade.
• EIP-7716 Correlated-failure attestation penalty weighting (Anti-Correlation Attestation Penalties) — When a validator misses an attestation, the penalty is scaled up by as much as 256x depending on how many more other validators than usual stopped at the same time. The penalty for a validator that misses alone stays the same as today.
• EIP-7709 BLOCKHASH storage reads and cost adjustment (Read BLOCKHASH from Storage and Update Cost) — The BLOCKHASH opcode is changed to read the hashes of the most recent 256 blocks from the storage of the EIP-2935 system contract, and charges an additional storage read cost accordingly. The returned value stays the same as today.
• EIP-7708 Log every ETH transfer (ETH Transfers Emit a Log) — For every ETH transfer with a nonzero value, the protocol automatically emits a log in the same format as an ERC-20 Transfer, so ETH movements from smart contract wallets can be tracked in a single way.
• EIP-7702 Set Code for EOAs (Set Code for EOAs) — Adds a new transaction type that lets an externally owned account (EOA) permanently set, on its own account, a delegation indicator pointing to specific contract code. It can behave like a smart contract wallet while keeping the existing address.
• EIP-7691 Blob throughput increase (Blob throughput increase) — Raises the number of blobs per block from a target of 3 and a maximum of 6 to a target of 6 and a maximum of 9. This doubles the L1 data space available to L2s and improves Ethereum's scalability in the short term.
• EIP-7685 Generalized execution layer requests (General purpose execution layer requests) — Creates a general-purpose channel that bundles requests made by smart contracts into a single hash in the block header (requests_hash) and delivers it to the consensus layer. The block structure does not need to change when a new request type appears.
• EIP-7668 Remove bloom filters (Remove bloom filters) — Forces the log bloom filters in execution blocks and transaction receipts to be empty. The bloom filter processing that every client performed goes away.
• EIP-7666 Moving the identity precompile to EVM code (EVM-ify the identity precompile) — Removes the identity precompile at address 0x04 (a built-in function that returns its input unchanged) and puts 7 bytes of EVM code that do the same job in its place. The functionality stays the same, and clients have one fewer precompile to implement separately.
• EIP-7645 Aliasing ORIGIN to SENDER (Alias ORIGIN to SENDER) — A proposal to change the EVM ORIGIN instruction so that, instead of the account that originally started the transaction, it returns the address of the immediate caller, that is, the same value as SENDER.
• EIP-7642 eth/69: History Expiry and Simpler Receipts (eth/69 - history expiry and simpler receipts) — Upgrades the communication protocol nodes use to exchange blocks (the eth protocol) to eth/69. It has each node announce the range of blocks it keeps and drops the unnecessary Bloom filter from receipts, which greatly reduces the amount of sync data.
• EIP-7623 Calldata Cost Increase (Increase calldata cost) — It sets a new floor on the calldata gas cost for transactions that mainly post data, which reduces the theoretical maximum block size. The cost of ordinary transactions with heavy EVM computation is unchanged.
• EIP-7610 Reject contract creation at addresses with leftover storage (Revert creation in case of non-empty storage) — Allows a contract to be created at an address only if its storage is empty, in addition to its nonce and code. Creation fails at an address where values remain in storage.
• EIP-7609 Lower the base cost of TLOAD/TSTORE (Decrease base cost of TLOAD/TSTORE) — Lowers the base gas cost of the transient storage opcodes TLOAD/TSTORE, and in exchange introduces a superlinear pricing model that adds extra cost the more slots are used, making common usage cheap and abuse expensive.
• EIP-7607 Hard fork meta: Fusaka (Hardfork Meta - Fusaka) — A meta EIP that compiles the list of EIPs included in the Fusaka (Fulu/Osaka) network upgrade and the activation schedule for each network. It is the upgrade following Pectra.
• EIP-7600 Pectra hard fork meta (Hardfork Meta - Pectra) — A document that compiles in one place which EIPs are included in the Prague/Electra (Pectra) network upgrade. It records 10 core EIPs, 2 other EIPs, and activation timing for each network.
• EIP-7594 PeerDAS (Peer Data Availability Sampling) (PeerDAS - Peer Data Availability Sampling) — A networking protocol that lets a node check only part of the blob data, without downloading all of it, and still be confident the data was actually published. It newly defines how blobs are propagated, stored and sampled.
• EIP-7587 Reserving precompile addresses for RIPs (Reserve Precompile Address Range for RIPs) — Reserves a precompile address range (0x0100 to 0x01ff) in advance for use by Rollup Improvement Proposals (RIPs) on L2s, so that it does not overlap with addresses assigned by EIPs.
• EIP-7569 Dencun hard fork meta (Hardfork Meta - Dencun) — A list-type (Meta) EIP that organizes the nine EIPs included in the Dencun network upgrade into a single document, divided between the execution layer and the consensus layer, and records activation timestamps for each network.
• EIP-7568 Hard fork meta backfill: Berlin through Shapella (Hardfork Meta Backfill - Berlin to Shapella) — A documentation-type meta EIP that consolidates and links the specification locations of past network upgrades, from the Beacon Chain launch through Shapella, that proceeded without a meta EIP. It does not change the network rules itself.
• EIP-7549 Moving the committee index out of the signature (Move committee index outside Attestation) — Removes the committee number (index) from the signed vote message, so consensus votes with identical content can be merged into one regardless of committee. This greatly reduces the number of signature verifications needed to check consensus and lets more votes fit in a block.
• EIP-7516 Blob base fee query opcode (BLOBBASEFEE instruction) — Adds the EVM opcode BLOBBASEFEE (0x4a), which lets smart contracts directly read the blob base fee of the current block.
• EIP-7514 Add a per-epoch cap on validator entry (Add Max Epoch Churn Limit) — Limits the number of newly activated validators to at most 8 per epoch. This slows the exponential growth of total staked ETH to linear growth, buying time to rediscuss the reward structure.
• EIP-7272 Ethereum Access Token (EAT) (Ethereum Access Token) — A standard in which an off-chain service issues an EIP-712 signed token to accounts that pass screening, and a smart contract verifies that token on-chain to temporarily permit a specific function call.
• EIP-7251 Higher validator maximum effective balance (Increase the MAX_EFFECTIVE_BALANCE) — Raises the effective balance cap that counts for a single validator from 32 ETH to 2048 ETH. While the 32 ETH minimum stays unchanged, this enables large operators to consolidate validators and solo stakers to compound their rewards.
• EIP-7045 Raising the attestation inclusion slot limit (Increase max attestation inclusion slot) — Extends the window in which a beacon chain attestation can be included in a block from one epoch after creation to the end of the next epoch. This change is needed for the LMD-GHOST security analysis and the fast finality rule.
• EIP-7044 Making voluntary exit signatures permanently valid (Perpetually Valid Signed Voluntary Exits) — Pins the signature verification of a validator's voluntary exit to the Capella fork domain. An exit message signed once stays valid through any later upgrade.
• EIP-7002 Execution Layer Triggerable Withdrawals (Execution layer triggerable withdrawals) — Lets the owner of a validator's withdrawal credentials (a 0x01 execution layer address) request validator exits and partial withdrawals directly from the execution layer. Requests are queued in a dedicated contract, then included in blocks and passed to the consensus layer.
• EIP-6916 Auto-resetting testnet (Automatically Reset Testnet) — A standard for testnets that automatically return to their initial state (genesis) after a set period. It lets clients compute a new genesis themselves and restart the network.
• EIP-6780 SELFDESTRUCT only in the same transaction (SELFDESTRUCT only in same transaction) — Reduces the functionality of the SELFDESTRUCT opcode, which removes a contract. Only when it is called in the very transaction in which the contract was created does it delete code and storage as before. Otherwise it only sends the balance to the recipient.
• EIP-6122 Timestamp-based fork ID check (Forkid checks based on timestamps) — Changes the fork ID (forkid) calculation, which nodes use to identify each other's chain configuration, so that it also handles forks scheduled by timestamp, not only by block number. After the Merge, forks are scheduled by time.
• EIP-6110 Onchain supply of validator deposits (Supply validator deposits on chain) — Validator deposit records are included as a list in execution layer blocks and passed directly to the consensus layer. The existing block proposer voting method (Eth1Data) is deprecated.
• EIP-5920 A PAY instruction that sends only ether without executing code (PAY opcode) — Adds a new EVM instruction, PAY (0xfc), that sends only ether without executing the recipient's code. Its purpose is to avoid reentrancy attacks and unnecessary gas costs when sending funds.
• EIP-5793 Add transaction type and size to transaction announcements (eth/68) (eth/68 - Add tx type to tx announcement) — Upgrades the wire protocol to eth/68, changing the message nodes use to announce new transactions so that it carries the transaction's type and size along with the hash, instead of the hash alone.
• EIP-5792 Wallet Call API (Wallet Call API) — Adds four JSON-RPC methods that let an app send several onchain calls to a wallet as one batch, check the processing status of that batch, and look up in advance the capabilities the wallet supports.
• EIP-5656 Memory copy instruction MCOPY (MCOPY - Memory copying instruction) — Adds MCOPY (0x5E), a dedicated instruction for copying memory regions, to the EVM. A 256-byte copy can be done for 27 gas, without a precompile call or repeated MLOAD/MSTORE.
• EIP-5133 Difficulty bomb delayed to mid-September 2022 (Delaying Difficulty Bomb to mid-September 2022) — Replaces the block number used in the difficulty calculation with a fake block number lowered by 11,400,000 blocks, which pushes the point at which the difficulty bomb becomes noticeable to mid-September 2022.
• EIP-4938 eth/67: Remove the GetNodeData message ("eth/67 - Removal of GetNodeData") — Removes the GetNodeData and NodeData messages from the wire protocol that nodes use to exchange data, and introduces a new protocol version, eth/67.
• EIP-4895 Push-style handling of beacon chain withdrawals (Beacon chain push withdrawals as operations) — An EIP that passes validator withdrawals finalized on the Beacon Chain to the execution layer as a new "system-level operation", unconditionally increasing the balance of the specified address without any gas fee.
• EIP-4844 Shard Blob Transactions (Shard Blob Transactions) — Introduces a new transaction format that places large data for rollups in a dedicated space called a "blob". Blobs have their own fee market separate from regular fees and can be deleted after a set period, so the storage burden is small.
• EIP-4788 Beacon block roots in the EVM (Beacon block root in the EVM) — Each execution block header includes the hash tree root of the parent beacon block, and these roots are stored in a dedicated smart contract, so consensus layer information can be verified inside the EVM.
• EIP-4758 Deactivate SELFDESTRUCT (Deactivate SELFDESTRUCT) — Replaces SELFDESTRUCT, the instruction that deletes a contract, with SENDALL. Only the function of sending all of the account's ether remains, the code and storage are not deleted, and the related gas refund is removed.
• EIP-4399 Replace the DIFFICULTY opcode with PREVRANDAO (Supplant DIFFICULTY opcode with PREVRANDAO) — Changes the DIFFICULTY (0x44) instruction, which loses its meaning when proof of work ends, so that it returns the beacon chain randomness (the RANDAO mix), and renames it PREVRANDAO.
• EIP-4345 Difficulty bomb delayed to June 2022 (Difficulty Bomb Delay to June 2022) — Changes the block difficulty calculation to use a fake block number, with 10,700,000 blocks subtracted from the real one, so that the effect of the difficulty bomb is pushed back to appear from June 2022.
• EIP-3860 Initcode size limit and metering (Limit and meter initcode) — Limits the maximum size of the initialization code (initcode) used to create a contract to 49152 bytes and charges an additional 2 gas for each 32-byte chunk.
• EIP-3855 Introducing the PUSH0 instruction (PUSH0 instruction) — Adds PUSH0 (0x5f), a 1-byte instruction that pushes the constant 0 onto the stack, to the EVM. It costs less gas than the existing PUSH1 0 and makes code shorter.
• EIP-3675 Switching Consensus to Proof-of-Stake (Upgrade consensus to Proof-of-Stake) — Ends proof-of-work (PoW) mining and replaces Ethereum mainnet's consensus mechanism with proof-of-stake (PoS) led by the beacon chain. It specifies the changes to the block structure, validity checks, fork choice rules, and network behavior needed for this.
• EIP-3651 COINBASE Starts Warm (Warm COINBASE) — Makes the COINBASE block proposer reward address warm from the start of a transaction, lowering the gas cost of accessing this address to match its actual cost.
• EIP-3607 Blocking transactions from addresses with deployed code (Reject transactions from senders with deployed code) — Declares invalid any transaction whose sending account is an address that already has contract code deployed. It is a rule that prevents fund theft attacks that exploit address collisions.
• EIP-3554 Difficulty bomb delayed to December 2021 (Difficulty Bomb Delay to December 2021) — A change that postpones the effect of the difficulty bomb so it appears in the first week of December 2021. Clients are made to compute difficulty using a fake block number, with 9,700,000 subtracted, instead of the real block number.
• EIP-3541 Ban deploying new code that starts with 0xEF (Reject new contract code starting with the 0xEF byte) — Blocks new deployment of contract code whose first byte is 0xEF. Code that is already deployed keeps its meaning and stays as it is.
• EIP-3529 Gas refund reduction (Reduction in refunds) — Removes the gas refund given when a contract is deleted (SELFDESTRUCT) and reduces the refund given for clearing a stored value to zero from 15,000 to 4,800 gas. It also lowers the cap on the refund a single transaction can receive from 1/2 of gas used to 1/5.
• EIP-3298 Storage clearing refund and removal of the refund cap (Remove storage-clear refund and refund cap) — Removes the SSTORE refund given for clearing storage (STORAGE_CLEAR_REFUND) and the transaction refund cap, leaving only the refund for writes reverted within the same transaction.
• EIP-3198 Add the BASEFEE opcode (BASEFEE opcode) — Adds the BASEFEE (0x48) opcode to the EVM so that smart contracts can read the base fee of the block currently being executed.
• EIP-2976 Network propagation of typed transactions (Typed Transactions over Gossip) — Makes it possible to send and receive typed transactions (Typed Transactions), introduced by EIP-2718, over devp2p, the communication protocol between nodes. This opens a path for transactions in new formats to actually propagate across the network.
• EIP-2935 Storing past block hashes in state (Serve historical block hashes from state) — The hashes of the most recent 8191 blocks are kept in the storage of a system contract as a ring buffer. Because block hashes are inside state, clients that hold only state can also look up and prove past hashes.
• EIP-2930 Optional access lists (Optional access lists) — Adds a new transaction type (type 1) that lets a transaction pre-declare the addresses and storage keys it will access. Accesses listed in advance pay a discounted gas cost upfront, while accesses outside the list are still possible but cost more.
• EIP-2929 Gas cost increase for state access opcodes (Gas cost increases for state access opcodes) — Raises the gas cost of the first read of an account or storage slot in a transaction by about 3x, while a repeated read within the same transaction costs only 100 gas. This rule was already included and applied in the 2021 Berlin hard fork.
• EIP-2780 Resource-based transaction base gas breakdown (Resource-Based Intrinsic Transaction Gas) — Breaks down the 21,000 base gas that every transaction pays equally into items based on the resources actually used. An ETH transfer to an existing account stays at 21,000, and a transaction that creates a new account pays an additional state growth cost.
• EIP-2718 Typed transaction envelope (Typed Transaction Envelope) — Introduces an envelope format that prepends a single byte indicating the type to the front of a transaction, so that new transaction types can be added in the future without colliding with each other.
• EIP-2681 Capping the account nonce at 2^64-1 (Limit account nonce to 2^64-1) — Restricts the values an account nonce can take to between 0 and 2^64-1. Once a nonce reaches the limit, transactions become invalid, and the CREATE and CREATE2 opcodes return 0 and halt.
• EIP-2565 ModExp gas cost recalibration (ModExp Gas Cost) — Redefines the gas cost formula for the ModExp precompile (address 0x05) to match its actual computational cost, lowering fees for cryptographic functions that rely on modular exponentiation.
• EIP-2537 BLS12-381 curve operation precompiles (Precompile for BLS12-381 curve operations) — Adds seven BLS12-381 elliptic curve operations as precompiles (built-in fast-operation functions) so smart contracts can efficiently verify BLS signatures and aggregate public keys.
• EIP-2488 Deprecate the CALLCODE opcode (Deprecate the CALLCODE opcode) — A proposal to effectively deprecate the unused early EVM opcode CALLCODE (0xf2) by making it always return failure (0) after the fork block.
• EIP-2481 eth/66 request identifier (eth/66 request identifier) — A request number (request_id) is attached to every request and response message in the eth protocol, which Ethereum nodes use to exchange data with each other. This change bumps the protocol version from eth/65 to eth/66.
• EIP-2464 eth/65: transaction announcement and retrieval ("eth/65: transaction announcements and retrievals") — Introduces a new protocol version, eth/65, which adds three message types that first announce only hashes for transaction propagation between nodes and then selectively retrieve only the ones not already known. This reduces the waste of repeatedly sending the same transaction in full to every peer.
• EIP-2384 Muir Glacier difficulty bomb delay (Muir Glacier Difficulty Bomb Delay) — As the difficulty bomb begins to lengthen block times again, this replaces the actual block number used in the difficulty calculation with a fake number that subtracts 9,000,000, pushing the bomb back by 4,000,000 blocks (about 611 days).
• EIP-2364 eth/64: fork ID handshake extension ("eth/64: forkid-extended protocol handshake") — Introduces eth/64, a new communication protocol that adds a fork identifier (forkid) to the handshake nodes exchange when first connecting. It disconnects incompatible nodes immediately, before expensive work.
• EIP-2200 A structural definition of net gas metering (Structured Definitions for Net Gas Metering) — Computes the gas for the contract storage instruction SSTORE based on the net change that actually remains when the transaction ends. The cost of repeatedly writing to the same storage slot drops significantly, and a safeguard against reentrancy attacks is included alongside it.
• EIP-2124 A fork identifier for checking chain compatibility (Fork identifier for chain compatibility checks) — Nodes exchange an identifier (forkid) that summarizes the genesis and the history of forks already passed as a 4-byte checksum, letting them tell before connecting whether a peer is a compatible node on the same chain.
• EIP-2028 Transaction data gas cost reduction (Transaction data gas cost reduction) — Lowers the gas cost of data (calldata) carried in a transaction from 68 gas to 16 gas per non-zero byte. The cost of zero bytes is left unchanged.
• EIP-1884 Rebalancing gas costs for state size dependent instructions (Repricing for trie-size-dependent opcodes) — Raises the gas cost of the state reading instructions SLOAD, BALANCE, and EXTCODEHASH, and adds a new instruction, SELFBALANCE, that reads the caller's own balance for 5 gas.
• EIP-1559 Fee market reform (introduction of the base fee) (Fee market change for ETH 1.0 chain) — Replaces the auction-determined transaction fee with a base fee that the protocol computes per block, which is then burned. Block size can also grow up to twice the target in response to demand.
• EIP-1344 Chain ID opcode (ChainID opcode) — Adds a new EVM instruction, CHAINID, that lets a smart contract directly read the chain ID of the network it is running on.
• EIP-1283 Net gas calculation for SSTORE without a dirty map (Net gas metering for SSTORE without dirty maps) — Recalculates the gas cost of the storage-write opcode SSTORE based on the actual net change remaining when the transaction ends. Writing to the same slot repeatedly costs only 200 gas from the second write onward.
• EIP-1234 Difficulty bomb delay and block reward adjustment (Constantinople Difficulty Bomb Delay and Block Reward Adjustment) — A change that delays the difficulty bomb's effect by about 12 months and lowers the block reward to 2 ETH in exchange. It proposes including this in the Constantinople hard fork, the second stage of Metropolis.
• EIP-1153 Transient storage opcodes (TLOAD/TSTORE) (Transient storage opcodes) — Adds transient storage to the EVM, which automatically disappears when a transaction ends. It is read and written with the new TLOAD and TSTORE opcodes, and is cheaper than persistent storage since it never touches disk.
• EIP-1108 alt_bn128 precompile gas cost reduction (Reduce alt_bn128 precompile gas costs) — Significantly lowers the gas cost of the elliptic curve operation precompiles (ECADD, ECMUL, pairing check) to match their actual computational speed. ECADD drops from 500 to 150, and ECMUL drops from 40,000 to 6,000.
• EIP-1052 EXTCODEHASH opcode (EXTCODEHASH opcode) — Adds a new instruction, EXTCODEHASH (0x3f), that directly returns the keccak256 hash of a contract's code. It lets you cheaply check another contract's code without copying the entire code.
• EIP-1014 Skinny CREATE2 (Skinny CREATE2) — Adds a new opcode, CREATE2 (0xf5), that computes a contract's address from a salt and the hash of the init code instead of the sending account's nonce. This lets the address be determined before deployment.
• EIP-868 Node discovery v4 ENR extension (Node Discovery v4 ENR Extension) — Adds two packets to node discovery protocol v4, the protocol Ethereum nodes use to find each other, so a node can directly request and receive another node's latest node record (ENR).
• EIP-778 Ethereum Node Records (ENR) (Ethereum Node Records (ENR)) — Defines Ethereum Node Records (ENR), an open format for carrying a node's connection information as signed key/value pairs. A sequence number indicates which information is most recent, and new fields can be added freely.
• EIP-706 DEVp2p Snappy compression (DEVp2p snappy compression) — Compresses all network messages exchanged between Ethereum nodes using the Snappy algorithm to reduce traffic. Data traffic drops by 60 to 80 percent for initial synchronization.
• EIP-684 Fail contract creation on address collision (Revert creation in case of collision) — Contract creation must fail if the target address already has a nonce or code. This prevents attacks that change deployed code after the fact.
• EIP-658 Recording the transaction status code in the receipt (Embedding transaction status code in receipts) — This replaces the intermediate state root field in the transaction receipt with a status code, recording 1 if the transaction succeeded and 0 if it failed. Anyone can check whether a transaction succeeded without re-executing it.
• EIP-649 Metropolis difficulty bomb delay and block reward reduction (Metropolis Difficulty Bomb Delay and Block Reward Reduction) — Starting from the Byzantium fork, this delays the activation of the difficulty bomb by about a year and a half, and lowers the block reward to 3 ETH so that issuance does not increase. Uncle and nephew rewards are adjusted by the same proportion.
• EIP-627 Whisper specification (Whisper Specification) — Standardizes the message format of Whisper, Ethereum's P2P messaging protocol. It covers packet codes, envelope structure, and the proof-of-work and bloom filter exchange method to ensure compatibility between clients.
• EIP-225 Clique proof-of-authority consensus protocol (Clique proof-of-authority consensus protocol) — Defines Clique, a proof-of-authority consensus mechanism in which only pre-approved signers can produce blocks. It reuses the existing block header structure as-is, making it easy to drop into any client.
• EIP-214 The static call instruction STATICCALL (New opcode STATICCALL) — Adds a new instruction, STATICCALL (0xfa), which calls another contract while disallowing any state changes within that call. Any attempt to change state is treated as an exception.
• EIP-211 New opcodes for querying return data ("New opcodes: RETURNDATASIZE and RETURNDATACOPY") — Adds two opcodes to the EVM: after a contract call finishes, the return data is held in a virtual buffer, with RETURNDATASIZE reading its size and RETURNDATACOPY copying its contents into memory.
• EIP-198 Big integer modular exponentiation precompile (Big integer modular exponentiation) — Adds a precompile at address 0x05 that computes big integer modular exponentiation (BASE**EXPONENT % MODULUS). This allows integer-theory-based cryptography such as RSA verification to be used efficiently inside the EVM.
• EIP-197 alt_bn128 pairing check precompile (Precompiled contracts for optimal ate pairing check on the elliptic curve alt_bn128) — Adds a precompiled contract at address 0x8 that performs a pairing check on the elliptic curve alt_bn128. Combined with EIP-196, this enables zkSNARK proofs to be verified inside a smart contract within the block gas limit.
• EIP-196 alt_bn128 curve addition and multiplication precompile (Precompiled contracts for addition and scalar multiplication on the elliptic curve alt_bn128) — Adds precompiled contracts for elliptic curve (alt_bn128) point addition and scalar multiplication at addresses 0x6 and 0x7. These are the basic operations needed to make zkSNARK verification feasible within the block gas limit.
• EIP-170 Contract code size limit (Contract code size limit) — Limits the maximum size of contract code that can be deployed on the blockchain to 24,576 bytes (0x6000). Attempting to deploy code larger than this causes contract creation to fail.
• EIP-161 State trie empty account clearing (State trie clearing (invariant-preserving alternative)) — Changes the account creation and gas charging rules so that 'empty accounts' with no code, nonce, or balance are deleted from state at the end of a transaction, and so that new empty accounts can no longer be created.
• EIP-160 Gas cost increase for the EXP operation (EXP cost increase) — Raises the gas cost charged for the EVM's exponentiation operation (EXP) from 10 to 50 per byte of the exponent. This is a finalized change that took effect with the Spurious Dragon hard fork at block 2,675,000.
• EIP-158 Cleanup of empty account state (State clearing) — A change that removes 'empty accounts' (accounts whose balance, nonce, and code are all empty) from Ethereum state and prevents new ones from being created going forward. This substantially reduces the state size that every node must store.
• EIP-155 Simple replay attack prevention (Simple replay attack protection) — Includes a chain-specific number (chain ID) in the transaction signature so that a transaction signed for one chain cannot be resubmitted as-is on another chain.
• EIP-152 BLAKE2 Compression Function F Precompile (Add BLAKE2 compression function `F` precompile) — Adds a precompile (a contract built into the client in advance) at address 0x09 that computes the compression function F at the core of the BLAKE2 hash algorithm. This sharply lowers the cost of interoperating with chains like Zcash.
• EIP-150 Gas cost increase for IO-intensive operations (Gas cost changes for IO-heavy operations) — Raises the gas cost of EVM operations that read state from disk to match their actual cost, and limits the gas that can be passed to a call to '63/64 of the remaining gas.' This is a hard fork applied at block 2,463,000 in response to the 2016 denial-of-service attacks.
• EIP-145 EVM bit shift instructions (Bitwise shifting instructions in EVM) — Adds three dedicated bit shift instructions to the EVM: SHL, SHR, and SAR. A shift operation that cost 35 gas when emulated with arithmetic operations now costs 3 gas.
• EIP-141 Designated invalid EVM instruction (Designated invalid EVM instruction) — This designates EVM opcode 0xfe as the permanently invalid instruction INVALID. A contract can use this instruction to deliberately halt execution.
• EIP-140 REVERT opcode (REVERT instruction) — Adds a REVERT opcode to the EVM that halts execution and reverts all state changes made so far. It allows the failure reason to be passed back to the caller without consuming all remaining gas.
• EIP-100 Difficulty adjustment based on block time including uncles (Change difficulty adjustment to target mean block time including uncles) — Changes the proof of work era difficulty adjustment formula so that it keeps the average block production rate steady including uncle blocks, not just main chain blocks. Applied starting from the Byzantium fork.
• EIP-8 devp2p Forward Compatibility Requirements (devp2p Forward Compatibility Requirements for Homestead) — Adds forward-compatibility rules to devp2p, the network protocol Ethereum nodes use to connect to each other, so that connections are not dropped when a peer's version differs and unknown data is simply ignored.
• EIP-7 Adding the DELEGATECALL Instruction (DELEGATECALL) — Adds a new instruction, DELEGATECALL (0xf4), to the EVM. It executes another contract's code while preserving the original call's sender and value information.
• EIP-5 Improving Gas Usage for RETURN and CALL* (Gas Usage for `RETURN` and `CALL*`) — Changes gas charging so that when a contract calls another contract, gas is charged only for the memory actually used at the point the call ends, not for the entire memory reserved in advance for output. This makes it possible to receive back strings and arrays whose length cannot be known in advance.
• EIP-2 Homestead Hard Fork Changes (Homestead Hard-fork Changes) — These are the four rule changes applied in the Homestead hard fork. They cover raising the gas cost of transaction-based contract creation, invalidating signatures with a high s value, clarifying the failure rule for contract creation, and replacing the mining difficulty adjustment formula.