Infrastructure

Simple replay attack protection

### Hard fork [Spurious Dragon](./eip-607.md)

Gas cost increases for state access opcodes

Increase the gas cost of `SLOAD` (`0x54`) to 2100, and the `*CALL` opcode family (`0xf1`, `f2`, `f4`, `fA`), `BALANCE` `0x31` and the `EXT*` opcode family (`0x3b`, `0x3c`, `0x3f`) to 2600. Exempts (i) precompiles, and (ii) addresses and sto

Typed Transaction Envelope

Defines a new transaction type that is an envelope for future transaction types.

Shard Blob Transactions

Shard Blob Transactions scale data-availability of Ethereum in a simple, forwards-compatible manner.

Set Code for EOAs

Add a new tx type that permanently sets the code for an EOA

Optional access lists

We introduce a new [EIP-2718](./eip-2718.md) transaction type, with the format `0x01 || rlp([chainId, nonce, gasPrice, gasLimit, to, value, data, accessList, signatureYParity, signatureR, signatureS])`.

Fee market change for ETH 1.0 chain

We introduce a new [EIP-2718](./eip-2718.md) transaction type, with the format `0x02 || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, amount, data, access_list, signature_y_parity, signature_r, sig

EOF - EVM Object Format v1

EOF is an extensible and versioned container format for EVM bytecode with a once-off validation at deploy time.

Contract code size limit

### Hard fork [Spurious Dragon](./eip-607.md)

Increase calldata cost

Increase calldata cost to reduce maximum block size

Block-Level Access Lists

Enforced block access lists with state locations and post-transaction state diffs

State trie clearing (invariant-preserving alternative)

### Hard fork [Spurious Dragon](./eip-607.md)

State Creation Gas Cost Increase

Harmonization, increase and separate metering of state creation gas costs to mitigate state growth and unblock scaling

Transient storage opcodes

Add opcodes for manipulating state that behaves almost identically to storage but is discarded after every transaction

Reject transactions from senders with deployed code

Do not allow transactions for which `tx.sender` has any code deployed.

Increase the MAX_EFFECTIVE_BALANCE

Allow validators to have larger effective balances, while maintaining the 32 ETH lower bound.

Transaction Gas Limit Cap

Introduce a protocol-level cap on the maximum gas used by a transaction to 16,777,216 (2^24).

New opcode STATICCALL

This proposal adds a new opcode that can be used to call another contract (or itself) while disallowing any modifications to the state during the call (and its subcalls, if present). Any opcode that attempts to perform such a modification (

Skinny CREATE2

### Specification

Supply validator deposits on chain

Provides validator deposits as a list of deposit operations added to the Execution Layer block

SELFDESTRUCT only in same transaction

SELFDESTRUCT will recover all funds to the target but not delete the account, except when called in the same transaction as creation

PeerDAS - Peer Data Availability Sampling

Introducing simple DAS utilizing gossip distribution and peer requests

General purpose execution layer requests

A general purpose bus for sharing EL triggered requests with the CL

SSZ ProgressiveList

SSZ types for efficiently hashing short lists

Homestead Hard-fork Changes

### Meta reference

Gas cost changes for IO-heavy operations

### Meta reference

Reduction in refunds

## Simple Summary

Limit and meter initcode

Limit the maximum size of initcode to 49152 and apply extra gas cost of 2 for every 32-byte chunk of initcode

Beacon chain push withdrawals as operations

Support validator withdrawals from the beacon chain to the EVM via a new "system-level" operation type.

Net gas metering for SSTORE without dirty maps

This EIP proposes net gas metering changes for `SSTORE` opcode, enabling new usages for contract storage, and reducing excessive gas costs where it doesn't match how most implementations work.

Reject new contract code starting with the 0xEF byte

Disallow new code starting with the `0xEF` byte to be deployed. Code already existing in the account trie starting with `0xEF` byte is not affected semantically by this change.

REVERT instruction

The `REVERT` instruction will stop execution, roll back all state changes done so far and provide a pointer to a memory section, which can be interpreted as an error code or message. While doing so, it will not consume all the remaining gas

Precompiled contracts for addition and scalar multiplication on the elliptic curve alt_bn128

This EIP suggests to add precompiled contracts for addition and scalar multiplication on a specific pairing-friendly elliptic curve. This can in turn be combined with [EIP-197](./eip-197.md) to verify zkSNARKs in Ethereum smart contracts. T

Precompiled contracts for optimal ate pairing check on the elliptic curve alt_bn128

This EIP suggests to add precompiled contracts for a pairing function on a specific pairing-friendly elliptic curve. This can in turn be combined with [EIP-196](./eip-196.md) to verify zkSNARKs in Ethereum smart contracts. The general benef

Big integer modular exponentiation

# Parameters

New opcodes: RETURNDATASIZE and RETURNDATACOPY

Please see summary.

Revert creation in case of collision

Revert contract creation if address already has code

EXTCODEHASH opcode

This EIP specifies a new opcode, which returns the keccak256 hash of a contract's code.

Serve historical block hashes from state

Store and serve last 8191 block hashes as storage slots of a system contract to allow for stateless execution

Beacon block root in the EVM

Expose beacon chain roots in the EVM

Execution layer triggerable withdrawals

Allow validators to trigger exits and partial withdrawals via their execution layer (0x01) withdrawal credentials

Increase Calldata Floor Cost

Increase the calldata floor cost to 64/64 gas per byte to reduce maximum block size

State-access gas cost update

Increases the gas cost of state-access operations to reflect Ethereum’s larger state

EOF - Code Validation

Validate EOF bytecode for correctness at the time of deployment.

Transaction data gas cost reduction

## Simple Summary We propose to reduce the gas cost of Calldata (`GTXDATANONZERO`) from its current value of 68 gas per byte to 16 gas per byte, to be backed by mathematical modeling and empirical estimates. The mathematical model is the on

Limit account nonce to 2^64-1

Limit account nonce to be between `0` and `2^64-1`.

PUSH0 instruction

Introduce a new instruction which pushes the constant value 0 onto the stack

SSZ ProgressiveContainer

SSZ type for forward-compatible containers

Blob base fee bounded by execution cost

Imposes that the price of GAS_PER_BLOB blob gas is greater than the price of BLOB_BASE_COST execution gas.

Add BLAKE2 compression function `F` precompile

This EIP introduces a new precompiled contract which implements the compression function `F` used in the BLAKE2 cryptographic hashing algorithm, for the purpose of allowing interoperability between the EVM and Zcash, as well as introducing

Metropolis Difficulty Bomb Delay and Block Reward Reduction

Starting with `BYZANTIUM_FORK_BLKNUM` the client will calculate the difficulty based on a fake block number suggesting the client that the difficulty bomb is adjusting around 3 million blocks later than previously specified with the Homeste

Embedding transaction status code in receipts

This EIP replaces the intermediate state root field of the receipt with a status code indicating if the top-level call succeeded or failed.

Reduce alt_bn128 precompile gas costs

Changes in 2018 to the underlying library used by the official Go reference implementation led to significant performance gains for the `ECADD`, `ECMUL`, and pairing check precompiled contracts on the `alt_bn128` elliptic curve.

ChainID opcode

This EIP adds an opcode that returns the current chain's EIP-155 unique identifier.

ModExp Gas Cost

To accurately reflect the real world operational cost of the `ModExp` precompile, this EIP specifies an algorithm for calculating the gas cost. This algorithm approximates the multiplication complexity cost and multiplies that by an approxi

BLOBBASEFEE instruction

Instruction that returns the current data-blob base-fee

Blob throughput increase

Increase the number of blobs to reach a new target and max of 6 and 9 blobs per block respectively

Set upper bounds for MODEXP

Each input field is restricted to a maximum of 8192 bits

ModExp Gas Cost Increase

Increases cost of ModExp precompile

Deterministic proposer lookahead

Pre-calculate and store a deterministic proposer lookahead in the beacon state at the start of every epoch

Precompile for secp256r1 Curve Support

Add precompiled contract for secp256r1 ECDSA signature verification with proper security checks

Frame Transaction

Add frame abstraction for transaction validation, execution, and gas payment

Change difficulty adjustment to target mean block time including uncles

### Specification

Bitwise shifting instructions in EVM

To Provide native bitwise shifting with cost on par with other arithmetic operations.

EXP cost increase

### Hard fork [Spurious Dragon](./eip-607.md)

Clique proof-of-authority consensus protocol

Clique is a proof-of-authority consensus protocol. It shadows the design of Ethereum mainnet, so it can be added to any client with minimal effort.

Constantinople Difficulty Bomb Delay and Block Reward Adjustment

Starting with `CNSTNTNPL_FORK_BLKNUM` the client will calculate the difficulty based on a fake block number suggesting the client that the difficulty bomb is adjusting around 5 million blocks later than previously specified with the Homeste

Repricing for trie-size-dependent opcodes

The growth of the Ethereum state has caused certain opcodes to be more resource-intensive at this point than they were previously. This EIP proposes to raise the `gasCost` for those opcodes.

Precompile for BLS12-381 curve operations

Adds operation on BLS12-381 curve as a precompile in a set necessary to efficiently perform operations such as BLS signature verification.

Resource-based intrinsic transaction gas

Decompose the flat intrinsic transaction cost into explicit primitives priced to match the resources a transaction actually consumes

BASEFEE opcode

Add a `BASEFEE (0x48)` that returns the value of the base fee of the current block it is executing in.

Warm COINBASE

Starts the `COINBASE` address warm

Difficulty Bomb Delay to June 2022

Delays the difficulty bomb to be noticeable in June 2022.

Delaying Difficulty Bomb to mid-September 2022

Delays the difficulty bomb by a further 700000 blocks, to the middle of September 2022.

MCOPY - Memory copying instruction

An efficient EVM instruction for copying memory areas

Increase max attestation inclusion slot

Increases max attestation inclusion slot to the last slot in `N+1` where `N` is the epoch containing the attestation's slot.

Add Max Epoch Churn Limit

Modify the churn limit function to upper bound it to a max value

Move committee index outside Attestation

Move committee index outside of the signed Attestation message

ETH transfers emit a log

All ETH transfers emit a log

RLP Execution Block Size Limit

Introduce a protocol-level cap on the maximum RLP-encoded block size to 10 MiB, including a 2 MiB margin for beacon block size.

Count leading zeros (CLZ) opcode

Opcode to count the number of leading zero bits in a 256-bit word

Empty accounts deprecation

Prohibit empty accounts on post-merge networks

Gas Usage for `RETURN` and `CALL*`

This EIP makes it possible to call functions that return strings and other dynamically-sized arrays. Currently, when another contract / function is called from inside the Ethereum Virtual Machine, the size of the output has to be specified

State clearing

# Specification

Difficulty Bomb Delay to December 2021

Starting with `FORK_BLOCK_NUMBER` the client will calculate the difficulty based on a fake block number suggesting to the client that the difficulty bomb is adjusting 9,700,000 blocks later than the actual block number.

Supplant DIFFICULTY opcode with PREVRANDAO

Expose beacon chain randomness in the EVM by supplanting DIFFICULTY opcode semantics

Automatically Reset Testnet

A testnet network that periodically rolls back to genesis

Block Gas Accounting without Refunds

Prevent Block Gas Limit Circumvention by Excluding Refunds from Block Gas Accounting

SLOTNUM opcode

Opcode to get the current slot number

Increase Access List Cost

Price access lists for data to reduce maximum block size

Revert creation in case of non-empty storage

Revert contract creation if address already has the non-empty storage

Remove SELFDESTRUCT Burn

Eliminate the remaining cases where SELFDESTRUCT burns ETH.

SSZ transactions

Migration of RLP transactions to SSZ

SSZ receipts

Migration of RLP receipts to SSZ

Forward compatible consensus data structures

Transition consensus SSZ data structures to ProgressiveContainer

Fork-choice enforced Inclusion Lists (FOCIL)

Allow a committee of validators to force-include a set of transactions in every block

Increase Maximum Contract Size

Raise the maximum contract code size from 24KiB to 64KiB and initcode size from 48KiB to 128KiB.

EOF - Static relative jumps

RJUMP, RJUMPI and RJUMPV instructions with a signed immediate encoding the jump destination

EOF - Functions

Individual sections for functions with `CALLF` and `RETF` instructions

GETCONTRACT opcode

Global byte code accessing by its hash

EOF - EXTCODEADDRESS instruction

Add EXTCODEADDRESS instruction to EOF to address code delegation use cases

EVM64 - 64-bit mode EVM opcodes

Multibyte opcodes for 64-bit arithmetic, comparison, bitwise and flow operations in EVM.

Call and Return Opcodes for the EVM

Three new instructions to support calls and returns.

Deterministic Factory Contract

A minimal `CREATE2` factory shared by EVM chains.

SSZ CompatibleUnion

SSZ type for forward-compatible unions

Exclude slashed validators from proposing

Modify proposer selection to exclude slashed validators, improving network resilience and performance after mass slashings

Increase exit and consolidation churn

Increase the exit and consolidation churn and create a separate consolidation churn limit parameter.

Reserve `EXTENSION (0xae)` opcode

Reserve an opcode to be used as an extension prefix in non-Ethereum-L1 EVM chains

Last-Written Block for Accounts and Slots

Records the last-written block number of each account and storage slot as consensus-level state metadata.

Specify restricted address range for precompiles/system contracts

The address range between 0x0000000000000000000000000000000000000000 and 0x000000000000000000000000000000000000ffff is reserved for precompiles and system contracts.

EOF - Stack Validation

Deploy-time validation of stack usage for EOF functions.

Chunk-Based Code Merkleization

Introduce code-chunking in an MPT context.

Statelessness gas cost changes

Changes the gas schedule to reflect the costs of creating a witness by requiring clients update their database layout to match.

SSZ withdrawals root

Migration of withdrawals MPT commitment to SSZ

Trustless log and transaction index

An efficient, light client and DHT friendly replacement for block header bloom filters

System logs

Per-block logs without associated transactions

SSZ execution blocks

Migration of execution blocks to SSZ

Linear, Page-Based Memory Costing

Linearize Memory Costing and replace the current quadratic formula with a page-based cost model.

EOF - Extended types section

Extend EOF container's types section with an extra type parameter.

Hard Limits for Transient Storage

Decrease costs for TLOAD and TSTORE with a transaction-global limit

Warm Account Write Metering

Introduce warm account writes, decreasing the cost of writing to an account after the first write.

Turn `randao_reveal` into a VRF

Transforms Ethereum’s `randao_reveal` into a per-slot BLS-based VRF by signing the previous epoch’s mix and current slot.

Multidimensional Gas Metering

Gas accounting by EVM resource, increasing throughput and improving resource usage controls, with minimal changes to the protocol and UX

Size-Based Storage Gas Pricing

Makes `SSTORE` gas cost scale with a contract's storage size to discourage state bloat.

Milli-gas for High-precision Gas Metering

Adds `milli-gas` as the EVM’s internal gas accounting unit, reducing rounding errors without impacting UX

Inter-Block Temporal Locality Gas Discounts

Multi‑block temporal locality discounts for state and account access

Contract Bytecode Deduplication Discount

Reduces gas costs for deploying duplicate contract bytecode via access-list based mechanism

Gas Units Rebase for High-precision Metering

Gas parameters and variables are increased to a factor of `REBASE_FACTOR` to reduce rounding errors without major changes to the EVM

Batch priority fees at end of block

Delay all priority fee credits from transactions to end of block

Replace cumulative receipt fields

Replace cumulativeGasUsed with gasUsed in on-chain receipt

Unified Transaction Content Floor

Flat 64 gas per content byte at the floor, covering all user-controlled transaction fields and capping worst-case block size.

Keyed Nonces for Frame Transactions

Independent nonce domains for frame transactions

Recent Roots for Frame Transactions

Frame transactions can declare verified recent roots

Partitioned Binary Tree

Switch Ethereum state tree to a partitioned binary tree

Remove storage-clear refund and refund cap

Removes the SSTORE storage-clearing refund and the transaction refund cap, leaving only net-metered same-transaction write reversals

PAY opcode

Introduces a new opcode, PAY, to send ether to an address without calling any of its functions

Precompile Falcon512 generic verifier

Add precompiled contract that allows generic signature verifications using Falcon512 postquantum algorithm

Read BLOCKHASH from Storage and Update Cost

Read the `BLOCKHASH (0x40)` opcode from the EIP-2935 system contract storage and adjust its gas cost to reflect storage access.

Anti-Correlation Attestation Penalties

Scales penalties for fully-offline validators by the excess of concurrently offline stake over its trailing average

State conversion to Verkle Tree

Describes a state conversion procedure to migrate key-values from the Merkle Patricia Tree to the Verkle Tree.

Reduce Block Latency

Reduce Ethereum's slot time from 12s to 6s to decrease latency by 50%, distribute bandwidth usage, and improve UX.

GAS2ETH opcode

Introduces a new opcode, `GAS2ETH`, to convert gas to ETH

SETDELEGATE instruction

Introduce a new instruction allowing contracts to create clones using EIP-7702 delegation designations

Code-Controlled EOA Delegation

Allow EIP-7702 delegated EOAs to update delegation through code while permanently disabling residual ECDSA authority.

Delayed State Root

Separate state root computation from block validation

Block-level Warming

Warm addresses and storage keys over the duration of a block

Ethereum state using a unified binary tree

Switch Ethereum state tree to a unified binary tree

Precompile for NTT operations

Proposal to add a precompiled contract that performs number theoretical transformation (NTT) and inverse (InvNTT).

Transaction Assertions via State Diff Opcode

Opcodes that expose a transaction's state diff to on-chain assertions that can reject the transaction's outcome

Meter Contract Code Size

Adds gas metering to contract code loading beyond 24KB

Scaling Ethereum with a Perceptron Tree ZKP

Improving Ethereum scalability and privacy using Perceptron Trees to compress transaction data via ZKP.

Available Attestation

A reorg-resilient solution for Ethereum

EVM64 - EOF code section

Define "pure" EVM64 mode, as an EOF code section.

Unified multidimensional fee market

Let transactions specify one aggregate `max_fee` budget for all resources, unify fee markets, normalize gas, and generalize EIP-7918.

Static relative jumps and calls for the EVM

Relative jump and call instructions with a signed immediate encoding the jump destination

Remove `deposit` and `eth1data` fields

Remove legacy deposit and Eth1 data fields from `BeaconBlockBody` and `BeaconState` after EIP-6110 finalization

Optional Execution Proofs

Introducing optional execution proofs on the consensus layer

P256 algorithm support

Adds an EIP-7932 algorithm type for P256 support of type `0x01`

Uniform price auction over inclusion lists

Ensure IL transactions that offer a higher ranking fee than competing transactions are included in the block. Burn the marginal ranking fee.

Precompile for Falcon support

Proposal to add a precompiled contract that performs signature verifications using the Falcon signature scheme.

Add sweep withdrawal fee for 0x01 validators

Improve stake consolidation and fairness by imposing a "sweep" withdrawal fee for `0x01` validators set to 0.05% of the withdrawn amount.

Prevent using consolidations as withdrawals

Cancels consolidation if the max effective balance of the target validator will be exceeded, preventing the withdrawal of the unused balance

Adaptive state cost to cap growth & scale L1

Track state bytes and target 250 MiB/day by dynamically adjusting the state gas cost. Exempt state from the gas limit to facilitate scaling.

Native rollups

Expose Ethereum's STF as a precompile for rollups to use

Let exits use the consolidation queue

Allows exits to use consolidation queue, democratizing access to an unintended feature, improving liquidity while preserving security.

Increase Gas Cost of Point Evaluation

Increases cost of point evaluation precompile

MEVless Protocol

A protocol that prevents MEV attacks by constraining transaction ordering through blind sequencing and two-phase block execution.

Payload Chunking with Chunk Access Lists

Semantic payload chunking with separated state diffs for streaming validation and reduced latency

Universal Enshrined Encrypted Mempool

Add a scheme agnostic encrypted mempool

MLOAD8 and CALLDATALOAD8 Opcodes

Adds EVM opcodes for efficient single-byte memory and calldata loads.

Temporary Contract Storage

Adds bounded-lifetime contract storage via TMPLOAD/TMPSTORE opcodes that is automatically cleared on a fixed schedule.

Keystore Accounts

Enable account abstraction through onchain keystore accounts and a new transaction type

Block-in-Blobs (BiB)

Ensures execution payload data availability via blobs

Block Access List Sidecars

Propagate block access lists as independent sidecars, off the critical path and ahead of the execution payload

Custom sweep threshold for validators

Allow setting custom balance thresholds for sweep withdrawals for validators with compounding withdrawal credentials (`0x02`).

Multi KZG Point Evaluation Precompile

Verify multiple (z, y) evaluations against a single EIP-4844 blob commitment in one precompile call.

Account Code Restricted ecRecover

Restrict ecRecover results to accounts with empty code or a delegation indicator

Native Key Delegation for EOAs

Allows EOAs to permanently replace ECDSA with alternative signature schemes via an extended delegation designator.

Composable Transaction

An extensible EIP-2718 transaction type with separated signatures, fee delegation via fee_auth, and opcodes for signature introspection

Binary SSZ Transport for the Engine API

Specifies a binary SSZ transport as an alternative to JSON-RPC for Engine API communication

LUCID encrypted mempool

Public encrypted mempool for commit-before-reveal inclusion of MEV-sensitive transactions, without enshrining a specific encryption scheme.

Cryptographically Agile Transactions

Cryptographically Agile Transaction format separating signature from transaction body

EVMification

Replace the RIPEMD-160, MODEXP, and BLAKE2f precompiles with equivalent EVM bytecode

Scheme-Agile Transactions

A new EIP-2718 transaction type with a common EIP-1559 fee header, scheme-agile sender authorization, and flat typed extensions

Commit-Reveal Transaction Frames

A Frame Transaction extension allowing delaying and concealing execution frame payload

Checked Arithmetic Opcodes

Adds opcodes for addition, subtraction, multiplication, and division that revert on overflow, underflow, or division by zero

Lean Staking

L1 native, two-phase staking with validator unlinkability

Independent CL/EL Sync

Enables independent consensus and execution layer synchronization by replacing execution_requests_root with an accumulator hash.

Batching Attestations at Source

Allow validators scheduled for duty on the same committee to publish a single pre-aggregated attestation in place of N individual ones

Bump nonce of zero-nonce storage accounts

Set nonce to 1 for accounts with empty code, zero nonce, and non-empty storage via an irregular state transition

Cap Deposit Requests Per Block

Limits the number of deposit requests in an Execution Layer block to 8192

Blob Streaming

Introduces ahead-of-time blob propagation via ticket-based capacity reservation.

Expiring Nonces for Frame Transactions

Short-lived replay protection for frame transactions via a sig-hash ring buffer

Storage Roots in Block Access Lists

Extend EIP-7928 with per-account post-block storage trie roots so partially stateful nodes can verify the state root

Block Access List Byte Floor

Meter EIP-7928 Block Access List bytes at runtime and fold them into the EIP-7623 transaction floor, capping worst-case block size.

Multi-block Access List Warming

Pre-warm the per-transaction access list with items from the previous 256 block access lists

Post-Quantum Attestation Aggregators

Describes the aggregator role that aggregates validator attestations into one succinct proof in PQ consensus

State Tiering by Periods

Tiered gas pricing for state writes based on renewal age, charging more for write-inactive state.

Fixed-Cutoff State Tiering

Surcharges writes to state unmutated since a fixed cutoff block

SETCODEFROM Code Reuse Instruction

Adds an instruction that sets an account's code hash from an existing deployed contract.

Trustless log and transaction index

Store the root hashes of index tables in a system contract to allow efficient trustless proofs of log and transaction lookups

Increase Calldata Floor Cost to 96

Increase the calldata floor cost to 96/96 gas per byte to align it with the ETH-transfer byte-density anchor

Hash-Chain RANDAO

Replace the BLS-signature RANDAO reveal with a post-quantum hash-chain commit-reveal scheme

Validated EVM Code

Code prefixed with MAGIC bytes is proven at CREATE time to have fully static control flow and to never underflow the data stack.

Offline State Migration to the PBT

Convert state to the PBT off the consensus-critical path, distribute a verifiable snapshot, and swap the commitment at a single fork

Precompiles for ML-DSA Verification

Three precompiles verifying ML-DSA signatures from a concatenated public key, signature, and trailing message

TCREATE Opcode

Introduce a new opcode for creating contracts that exist only for the duration of a single transaction

Tapered Issuance Burn

Burn a fraction of validator rewards that rises with the staking ratio, removing the issuance incentive to stake more than 50% of all ETH

Disallow new 0x00 validators

Reject deposits that would create new validators with 0x00 withdrawal credentials, leaving existing validators untouched

CPSB Recalibration for New Gas Limit

Re-derives the cost per state byte (CPSB) parameter introduced in EIP-8037 for a new reference block gas limit

Normalized state gas limit

Scales and normalizes the state-gas limit to better balance state-gas and execution-gas utilization.

Top-up Sync

CL-driven EL synchronization by exposing the execution client head and distinguishing missing state from missing history in the engine API

Remove the Sync Committee

Remove the onchain Altair sync committee and its rewards, superseded by offchain ZK proofs

PRECOMPILEDCALL opcode (Remove CALL costs for precompiled contracts)

This EIP tries to resolve the problem of high gas consumption when calling precompiled contracts with a small gas cost. Using this opcode for calling precompiled contracts allows to define precompiled contracts whose effective cost it is le

Reduced gas cost for static calls made to precompiles

Reduce the base gas cost of calling precompiles using `STATICCALL` from 700 to 40. This should allow more efficient use of precompiles as well as precompiles with a total cost below 700.

Nonce Cap

Caps the nonce at 2^64-2

Ethereum state using a unified verkle tree

This introduces a new Verkle state tree alongside the existing MPT.

Revamped CALL instructions

Introduce EXTCALL, EXTDELEGATECALL and EXTSTATICCALL with simplified semantics

EOF Contract Creation

Introduce `EOFCREATE` and `RETURNCODE` instructions

Remove bloom filters

Remove bloom filters from the execution block

State Rent A - State counters contract

This is part of the State Rent roadmap. This particular change introduces a place in the Ethereum state where various state counters can be stored. At this point, the most important counter is the total number of transactions happened, and

BLS12-377 curve operations

Precompiles for BLS12-377 curve operations

Paged memory allocation for the EVM

Presently, the EVM charges for memory as a linear array starting at address 0 and extending to the highest address that has been read from or written to. This suffices for simple uses, but means that compilers have to generate programs that

Transaction Data Opcodes

This EIP introduces the following three EVM instructions: `ORIGINDATALOAD`, `ORIGINDATASIZE`, and `ORIGINDATACOPY`.

Limit transaction gas to a maximum of 2^63-1

Valid transactions must have a reasonable gas limit

Alias Contracts

Allows the creation of contracts that forward calls to other contracts

EOF - JUMPF and non-returning functions

Introduces instruction for chaining function calls.

EOF - Data section access instructions

Instructions to read data section of EOF container

Verkle proof verification precompile

Add a precompile to help dapps verify verkle proofs

Verkle state transition via an overlay tree

Describes the use of an overlay tree to use the verkle tree structure, while leaving the historical state untouched.

Linear EVM memory limits

Adjust memory limits and gas limits of sub-calls to create a clear linear bound on how much total memory an EVM execution can consume

EOF - Creation transaction

Deploy EOF contracts using creation transactions

Uncouple blob count between CL and EL

Have CL verify blob maximum and have EL get target value from CL

EXTCODETYPE instruction

Add EXTCODETYPE instruction to EOF to address common uses of EXTCODE* instructions

Serenity Currency and Crypto Abstraction

### Specification

Blockhash refactoring

### Summary

Subroutines and Static Jumps for the EVM

EVM code is currently difficult to statically analyze, hobbling critical tools for preventing the many expensive bugs our blockchain has experienced. Further, none of the current implementations of the Ethereum Virtual Machine—including the

SIMD Operations for the EVM

A proposal to provide Single Instruction Multiple Data types and operations for the Ethereum Virtual Machine, making full use of the 256-bit wide EVM stack items, and offering substantial performance gains for both vector and scalar operati

Address Collision of Contract Address Causes Exceptional Halt

Some test cases in the consensus test suite try to deploy a contract at an address already with nonempty code. Although such cases can virtually never happen on the main network before the Constantinople fork block, the test cases detected

OPCODE 0x46 BLOCKREWARD

In the EVM, the 0x40 opcodes are reserved for `Block Information`. Currently reserved opcodes are: * `0X40 BLOCKHASH` * `0X41 COINBASE` * `0X42 TIMESTAMP` * `0X43 NUMBER` * `0X44 DIFFICULTY` * `0X45 GASLIMIT`

Reduce block reward and delay difficulty bomb

The current public Ethereum network has a hashrate that corresponds to a tremendous level of energy consumption. As this energy consumption has a correlated environmental cost the network participants have an ethical obligation to ensure th

Modifications to ethash to invalidate existing dedicated hardware implementations

There are companies who currently have dedicated hardware based ethereum miners in production, and may be actively mining. This EIP aims to "poison the well" by modifying the block mining algorithm in a low risk manner that may *"break"* th

Uniformity Between 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B and 0x15E55EF43efA8348dDaeAa455F16C43B64917e3c

As of the date of this EIP, the difference in balance between address `0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B` and address `0x15E55EF43efA8348dDaeAa455F16C43B64917e3c` is far from equitable or uniform, with the former having more than 3

Hybrid Casper FFG

This EIP specifies a hybrid PoW/PoS consensus model for Ethereum main net. Existing PoW mechanics are used for new block creation, and a novel PoS mechanism called Casper the Friendly Finality Gadget (FFG) is layered on top using a smart co

Configurable On Chain Issuance

## Simple Summary

Overflow checking for the EVM

This EIP adds overflow checking for EVM arithmetic operations, and two new opcodes that check and clear the overflow flags.

Net gas metering for SSTORE operations

This EIP proposes a change to how gas is charged for EVM `SSTORE` operations, in order to reduce excessive gas costs in situations where these are unwarranted, and to enable new use-cases for contract storage.

Defuse Difficulty Bomb and Reset Block Reward

Starting with `FORK_BLKNUM` the client will calculate the difficulty without the additional exponential component. Furthermore, block rewards will be adjusted to a base of 5 ETH, uncle and nephew rewards will be adjusted accordingly.

Eliminate Difficulty Bomb and Adjust Block Reward on Constantinople Shift

Starting with `CNSTNTNPL_FORK_BLKNUM` the client will calculate the difficulty without considering the current block number. Furthermore, block rewards will be adjusted to a base of 2 ETH, uncle and nephew rewards will be adjusted according

Increase Gcallstipend gas in the CALL opcode

Currently, the ``CALL`` opcode forwards a stipend of ``2,300`` gas units for a non zero value ``CALL`` operations where a contract is called. This stipend is given to the contract to allow execution of its ``fallback`` function. The stipend

Modify Ethereum PoW Incentive Structure and Delay Difficulty Bomb

Starting with CNSTNTNPL_FORK_BLKNUM the client will calculate the difficulty based on a fake block number suggesting the client that the difficulty bomb is adjusting around 6 million blocks later than previously specified with the Homestead

Reduced gas cost for call to self

Reduce the gas cost for call instructions, when the goal is to run a new instance of the currently loaded contract.

Blockchain Storage Rent Payment

At each block, deduct value from every account based on the quantity of storage used by that account.

TEthashV1

This EIP pursue "obsolete current ASIC miners" by modifying PoW algorithm in a very low risk manner and update to latest hash algorithm from deprecated FNV Hash algorithms.

Temporal Replay Protection

## Simple Summary

Generalized Account Versioning Scheme

This defines a method of hard forking while maintaining the exact functionality of existing account by allowing multiple versions of the virtual machines to execute in the same block. This is also useful to define future account state struc

Precompile for Elliptic Curve Linear Combinations

A precompile that takes a curve and computes a linear combination of curve points.

Commitment to Sustainable Ecosystem Funding

A mechanism that allows specification of two parameters, a beneficiary address and a per-block reward denominated in wei, that allows a portion of block rewards to be captured for the purpose of ecosystem funding. Both values are set to zer

Support for an Elliptic Curve Cycle

Adds supports for the following operations through precompiles:

CALLs with strict gas semantic. Revert if not enough gas available.

The current CALL, DELEGATE_CALL, STATIC_CALL opcode do not enforce the gas being sent, they simply consider the gas value as a maximum. This pose serious problem for applications that require the call to be executed with a precise amount of

New Opcode to check if a chainID is part of the history of chainIDs

This EIP adds an opcode that returns whether the specific number passed in has been a valid chainID (EIP-155 unique identifier) in the history of the chain (including the current chainID).

Method to check if a chainID is valid at a specific block Number

This EIP adds a precompile that returns whether a specific chainID (EIP-155 unique identifier) is valid at a specific blockNumber. ChainID are assumed to be valid up to the blockNumber at which they get replaced by a new chainID.

Sane limits for certain EVM parameters

Introduce an explicit value range for certain EVM parameters (such as gas limit, block number, block timestamp, size field when returning/copying data within EVM). Some of these already have an implicit value range due to various (practical

State Rent H - Fixed Prepayment for accounts

This is part of the State Rent roadmap. This particular change introduces a fixed charge for state expansion that comes from adding new accounts to the state. Theoretically, it puts a bound on the number of accounts that can be ever created

State Rent C - Net contract size accounting

This is part of the State Rent roadmap. This particular change introduces initial, net accounting of the number of the contract storage slots. Though not very useful on its own, it makes it possible to introduce gross accounting of the numb

State Rent B - Net transaction counter

It is part of the State Rent roadmap. This particular change makes any Ethereum transaction increment the transaction counter, which is a special storage slot in the *State counter contract*. This counter will be used to populate the nonces

Stateless Clients - Repricing SLOAD and SSTORE to pay for block proofs

It is part of the State Rent roadmap. This particular change prepares Ethereum for introduction of the block proofs (current understanding is that they can be introduced without a hard fork). The introduction of the block proofs allows any

Particle gas costs for EVM opcodes

According to recent benchmarks, EVM opcodes for computation (`ADD`, `SUB`, `MUL`, etc.) are generally overpriced relative to opcodes for storage I/O (`SLOAD`, `SSTORE`, etc.). Currently the minimum gas cost is 1 (i.e. one unit of gas), and

Transaction Postdata

A paradigm shift in how blockchains are used has been seen recently in Eth 2.0, with the rise of [_Execution Environments_](https://notes.ethereum.org/w1Pn2iMmSTqCmVUTGV4T5A?view) (EEs), and [_stateless clients_](https://ethresear.ch/t/the-

Simple Subroutines for the EVM

Two opcodes for efficient, safe, and static subroutines.

BEGINDATA opcode

It is common for smart contracts to efficiently store data directly in the contract bytecode. Examples include constructor arguments, constant variables, compiler metadata and the contract runtime during the init phase. Currently, such data

EXTSLOAD opcode

A new EVM opcode to read external contract storage data.

Coinbase calls

_In proof-of-work blockchains, validators are known as miners._

Deprecate the CALLCODE opcode

Deprecate `CALLCODE` in a *somewhat* backwards compatible way, by making it always return failure.

Implement Difficulty Freeze

The difficulty Freeze is a mechanism that is easy to predict and model, and the pressures of missing it are more readily felt by the core developers and client maintainers. The client maintainers are also positioned as the group that is mos

Penalty for account trie misses

This EIP adds a gas penalty for accesses to the account trie, where the address being looked up does not exist. Non-existing accounts can be used in DoS attacks, since they bypass cache mechanisms, thus creating a large discrepancy between

Trie format transition with overlay trees

This EIP describes a four phase process to complete the conversion.

Escalator fee market change for ETH 1.0 chain

Based on [The Agoric Papers](https://agoric.com/papers/incentive-engineering-for-computational-resource-management/full-text/).

Repricing of precompiles and Keccak256 function

Costs of many precompiles and built-in functions are invalid at the current state of the clients. This EIP contains a list of changes to the pricing formulas to better reflect underlying computations' structure.

Rich Transactions

Support 'rich transactions' by allowing transactions from externally owned accounts to execute bytecode directly.

EXTCLEAR Opcode For SELFDESTRUCTed contracts

Changes `SELFDESTRUCT` (`0xff`) to not clear any storage and adds a new `EXTCLEAR` (`0x5c`) opcode that will clear a specific storage slot for a contract that has previously been self destructed.

SET_INDESTRUCTIBLE opcode

IS_STATIC opcode

IMPERSONATECALL Opcode

Add a new opcode, `IMPERSONATECALL` at `0xf6`, which is similar in idea to `CALL (0xF1)`, except that it impersonates a sender, i.e. the callee sees a sender different from the real caller. The impersonated sender address is derived from th

BW6-761 curve operations

Precompiles for BW6-761 curve operations

Precompile for BN256 HashToCurve Algorithms

There is currently no inexpensive way to perform BLS signature verification for arbitrary messages. This stems from the fact that there is no precompiled contract in the EVM for a hash-to-curve algorithm for the BN256 elliptic curve. The ga

AUTH and AUTHCALL opcodes

Allow externally owned accounts to delegate control to a contract.

Binary trie structure

This proposal presents a binary structure and merkelization rule for the account and storage tries, which are merged into a single “state” trie. RLP and most of the MPT’s optimizations are dropped to simplify the design. Keccak256 is replac

Increase block rewards to 5 ETH

Starting with `FORK_BLKNUM` block rewards will be increased to a base of 5 ETH, uncle and nephew rewards will be adjusted accordingly.

Crosschain Identifier Specification

The crosschain-id is a 32 byte hex string and with some bytes extracted from blockchain hash and some manually defined to characterize a blockchain. We also propose a registration and lookup service to retrieve blockchain metadata from the

Difficulty Bomb Delay to Q2/2022

Starting with `FORK_BLOCK_NUMBER` the client will calculate the difficulty based on a fake block number suggesting to the client that the difficulty bomb is adjusting eleven million blocks later than the actual block number.

Giving Ethereum fees to Future Salaries

Transfer a part (exact fractions - TBD) of mining/transfer fees + (probably: TBD) some minted ETH to the `DonateETH` contract configured to transfer to `SalaryWithDAO` contract.

Phase out refunds

This EIP would define a block when the `SSTORE` and `SELFDESTRUCT` refunds would begin to diminish. The refund would step linearly downward, eroding the implicit value of such refunds at an accelerating pace.

Account gas storage opcodes

Contracts can persist gas for later transfer to the refund counter. Three opcodes are introduced to read, add to, and use this gas counter.

Frame pointer support for memory load and store operations

This EIP introduces four new opcodes, `MLOADFP`, `MSTOREFP`, `GETFP` and `SETFP` that allow for more efficient memory access offset by a user-controlled quantity called the "frame pointer". This permits compilers to more efficiently offload

Increase block rewards to 3 ETH, with 2 Year Decay to 1 ETH Scheduled

Set the block reward to 3 ETH and then decrease it slightly every block for 4,724,000 blocks (approximately 2 years) until it reaches 1 ETH.

5 FNV primes for ethash

This EIP is to kick current ASIC implementations out of the network to keep the Ethereum network secure and healthy by changing the `fnv` constants.

Partial removal of refunds

## Simple Summary

Median Gas Premium

There is a base fee per gas in protocol, which can move up or down by a maximum of 1/8 in each block. The base fee per gas is adjusted by the protocol to target an average gas usage per block instead of an absolute gas usage per block. The

Expanded Clique Block Choice Rule

The current specification of Clique allows for multiple competing blocks from producers but does not provide any strategies to pick blocks aside from the current "highest total difficulty" rule. This EIP proposes a four step choice rule of

SUDO Opcode

A new opcode is introduced to allow calling from an arbitrary sender address.

Transaction Destination Opcode

This EIP introduces the following EVM instruction: `ENTRYPOINT`.

Reduce access list cost

## Simple Summary

Restricted Chain Context Type Transactions

We introduce a new EIP-2718 transaction type with the format `0x4 || rlp([chainId, chainContext, nonce, gasPrice, gasLimit, to, value, data, access_list, yParity, senderR, senderS])`.

Block Access List

[EIP-2929](./eip-2929.md)/[EIP-2930](./eip-2930.md) centers around normalizing the (low) gas costs of data/storage accesses made by a transaction as well as providing for (and encouraging) a new transaction type format: ``` 0x01 || rlp([cha

EOF - JUMPDEST Table

A special EOF section for storing the list of JUMPDESTs, which simplifies execution time analysis.

Gas Limit Cap

Set an in-protocol cap for the gas limit

Safer Control Flow for the EVM

Ensure an essential level of safety for EVM code.

Strict enforcement of chainId

Reject transactions that do not explicitly have the same chainId as the node's configuration.

Gas refunds on reverts

Reprice reverted SSTORE/CREATE/SELFDESTRUCT/LOGX operations gas via gas refund mechanism

Time-Aware Base Fee Calculation

Accounts for block time in the base fee calculation to target a stable throughput by time instead of by block.

Transaction calldata gas cost reduction with total calldata limit

Greatly decreases the gas cost of transaction calldata and simultaneously caps total transaction calldata in a block

Multi-byte opcodes prefixed by EB and EC.

Reserve `0xEB` and `0xEC` for usage as extended opcode space.

Procedures for the EVM

Introduces support for EVM Procedures.

Simplify EIP-161

Simplify EIP-161 and retroactively deprecate unused aspects of it

Deactivate SELFDESTRUCT

Deactivate SELFDESTRUCT by changing it to SENDALL, which does recover all funds to the caller but does not delete any code or storage.

SELFDESTRUCT bomb

Deactivate SELFDESTRUCT by changing it to SENDALL and stage this via a stage of exponential gas cost increases.

Beacon chain push withdrawals

Support validator withdrawals from the beacon chain to the EVM via a new "push-style" transaction type.

MULDIV instruction

Introduce a new instruction to perform x * y / z in 512-bit precision

Increase price of SSTORE from zero to non-zero to 40k gas

Increase the price of the SSTORE opcode from `20_000` gas to `40_000` gas when the original slot is zero and the resultant slot is non-zero.

Remove the limit on contract code size

Change the limit on contract size from 24576 to infinity

Instruction for transferring ether

Instruction for just transferring ether without transferring the flow of execution

Expirable Transaction

This EIP adds a new transaction type of that includes expiration with a blocknum

Semaphore for Reentrancy Protection

A Precompile-based parallelizable reentrancy protection using the call stack

CREATE2COPY Opcode

Reducing the gas cost of contract creation with existing code

Delegate transaction

Adds a new transaction type that allows EOAs to execute arbitrary code through delegation

Add Poseidon hash function precompile

Add a precompiled contract which implements the hash function used in the Poseidon cryptographic hashing algorithm

Replace SELFDESTRUCT with DEACTIVATE

Change SELFDESTRUCT to not delete storage keys and use a special value in the account nonce to signal deactivation

Verkle-compatible SELFDESTRUCT

Changes SELFDESTRUCT to only cause a finite number of state changes

SSZ Optional

New SSZ type to represent optional values

EVM Modular Arithmetic Extensions

Expanded-width, efficient modular arithmetic operations for the EVM

Ex Post Facto Cascading Revert

Allow transactions to be reversed after confirmation

To The Moon—10 Minute Blocks

Increases the block time to facilitate finality over cosmic distances

Preimage retention

Execution clients must retain the preimages of addresses and slots accessed between the fork preceding the verge, and the verge itself.

Arithmetic verification at EVM level

Check for math overflows and division by zero at EVM level

Reuse Withdrawn Validator Indices

Reuse fully withdrawn and safe to reuse validator indices for new beacon chain deposits.

Contract Secured Revenue on an EVM based L2

Contract Secured Revenue on an EVM based L2

Elected block proposer has not been slashed

Prevents a slashed validator from being elected as a block proposer

Remove BLAKE2 compression precompile

Remove the blake2f (0x09) precompile by changing the precompile behaviour to result in an exceptional abort

Migration Transaction

Allow EOAs to send a one-time transaction which deploys code at their account.

Add time-weighted averaging to the base fee

Using geometric weights to average past block sizes into consideration

Zero-Knowledge Wormholes

Enable minting of secretly burnt Ethers as a native privacy solution for Ethereum

Atomic Storage Operations SCREDIT and SDEBIT

Add atomic operations for incrementing and decrementing storage slots

EVM arbitrary precision decimal math

This EIP adds OPCODEs to allow arbitrary precision decimal float calculation of all elementary functions with precise gas enumeration.

Inclusion lists

Add an inclusion list mechanism to allow forced transaction inclusion.

Block-level Warming with fair cost savings

Block-level warming of addresses and slots with access lists

Decrease base cost of TLOAD/TSTORE

Improve the efficiency of TLOAD/TSTORE by decreasing the base cost and introducing a superlinear pricing model.

Optimize EOA EXTCODEHASH

Modify the output value of EXTCODEHASH for EOA accounts to `0x`

History accumulator for pre-PoS data

Commit to a single root for all block data before the merge.

Alias ORIGIN to SENDER

Eliminate ORIGIN tech debt to lay groundwork for account abstraction and close security holes

Sync committee slashings

Slashing condition for malicious sync committee messages

Light client data backfill

Mechanism for beacon nodes for syncing historical light client data

Raise gas costs of hash functions

Raise the gas costs of hash function opcodes and precompiles, to match prover expenses in ZK-EVMs

EOF - Prepare for Address Space Extension

Update EOF opcodes so addresses are not trimmed during execution

Increase calldata cost

Increase calldata cost to decrease the maximum block size

NONREENTRANT and REENTRANT opcodes

Opcodes to mark a contract as nonreentrant

Separate gas type for calldata

Create a separate basefee and gaslimit for calldata

Incentivize Access List Provisioning

This EIP proposes updating gas cost parameters for access lists to incentivise their use and improve transaction execution efficiency.

EVM Transaction Bundles

Enable meta transactions to order other transactions without revert protections.

Leaf-level state expiry in verkle trees

Simple state expiry scheme in which only "extension-and-suffix trees" are expired.

Increase MIN_BASE_FEE_PER_BLOB_GAS

Adjust the MIN_BASE_FEE_PER_BLOB_GAS to speed up price discovery on blob space

BURN opcode

An opcode to burn native ether at the given address

Verifiable logs

Scheme to make the eth_getLogs response verifiable