EIP-7807 Proposes Migrating Ethereum Execution Blocks from RLP to SSZ Encoding: When Ethereum's Oldest Data Format Meets Its Most Ambitious Cleanup

The proposal appeared on the Ethereum Magicians forum in September 2026 with the patient determination of developers who had spent years explaining why RLP—Recursive Length Prefix, Ethereum's original data serialization format—was both a historical artifact and a ongoing source of inefficiency. EIP-7807 proposes a complete migration of execution layer block encoding from RLP to SSZ—Simple Serialize, the format already used by the consensus layer. The pitch was technical: SSZ is more efficient, type-safe, and aligned with the consensus layer's serialization approach. RLP is ad-hoc, ambiguously typed, and requires custom parsing logic that has been a source of bugs since 2015. The fine print raised a question about whether migrating the entire execution layer's data format is a necessary modernization or a risky refactoring of Ethereum's most critical data path that could introduce consensus failures in the name of cleanliness.

That was the proposal. Then came the question of whether changing how every block, transaction, and receipt is serialized is a performance optimization or a protocol-level gamble that trades known bugs for unknown ones.

What EIP-7807 Actually Proposes

The proposal describes a foundational change to how Ethereum execution data is encoded and transmitted:

The Migration Scope:

- All execution layer block structures (header, transactions, receipts, logs) migrate from RLP to SSZ encoding

- The Engine API between consensus and execution layers switches to SSZ-native communication

- Historical blocks remain RLP-encoded; only new blocks use SSZ

- Client implementations add dual-read capability for historical data access

- The eth_getBlockByHash and related JSON-RPC methods return SSZ-encoded data or translated JSON

RLP vs SSZ Comparison:

- RLP: Dynamic typing, recursive length-prefix encoding, requires schema inference from context, no fixed-size guarantees, custom parser per data type

- SSZ: Static typing, fixed-offset fields, merkleization-friendly, canonical hashing, alignment with consensus layer, formally specified

Expected Benefits:

- Performance: SSZ parsing is 15-30% faster than RLP for typical block sizes

- Type Safety: SSZ's static typing eliminates an entire class of deserialization bugs

- Alignment: Execution and consensus layers use the same serialization format

- Merkleization: SSZ structures can be merkleized for light client proofs

- Tooling: Standardized SSZ libraries replace custom RLP parsers in every client

Implementation Complexity:

- Every execution client (Geth, Nethermind, Besu, Erigon, Reth) must rewrite block serialization

- The Engine API specification requires updates

- Historical block access needs translation layers

- Testing must cover dual-format consensus validation

- Rollup sequencers and L2 infrastructure must adapt

The proposal frames these as technical debt repayment. They are also a fundamental change to Ethereum's most critical data path.

Key Metrics at a Glance

The Proprietary Serialization Transition Risk Score (STRS)

I've developed a framework to evaluate whether migrating Ethereum's execution layer serialization is worth the implementation risk:

Formula: STRS = (Technical Benefit × 0.3) + (Implementation Confidence × 0.25) + (Ecosystem Coordination × 0.25) + (Rollback Safety × 0.2)

EIP-7807 Assessment:

A score of 4.55 indicates that EIP-7807 is a technically sound improvement with substantial execution risk. The benefits are real but the coordination required is massive.

The Three Serialization Traps

Trap 1: The Consensus Split

The greatest risk in any serialization change is that different clients parse the same data differently. RLP has been battle-tested for eleven years. Every client has implemented it, debugged it, and hardened it against edge cases. SSZ is well-specified but new to the execution layer. If Geth's SSZ parser disagrees with Nethermind's SSZ parser on a single edge case, the network splits. The split may not be detectable until a block is processed differently by different clients. At that point, the network is already forked. The rollback requires emergency coordination, client patches, and potentially manual intervention by validators. The serialization format that was supposed to improve reliability becomes the cause of consensus failure.

Trap 2: The Ecosystem Drag

Ethereum's execution layer does not exist in isolation. Every rollup sequencer encodes and decodes execution data. Every block explorer parses transactions. Every wallet constructs and signs transactions. Every indexer processes receipts and logs. Every bridge validates block headers. All of these systems understand RLP. None of them understand SSZ. The proposal assumes that the ecosystem will upgrade. History suggests otherwise. The DAO fork in 2016 took months for ecosystem coordination. The Berlin hard fork in 2021 broke multiple infrastructure providers. The Merge in 2022 required years of preparation. EIP-7807 is simpler than The Merge in concept but more complex in ecosystem scope. The execution layer may upgrade smoothly while the ecosystem fragments.

Trap 3: The Historical Data Burden

The proposal states that historical blocks remain RLP-encoded. This sounds reasonable. In practice, it means every execution client must maintain dual parsers indefinitely. Every historical block query must use the RLP parser. Every new block must use the SSZ parser. Every tool that processes both historical and current data must handle both formats. The "clean" migration creates permanent dual-format complexity. The technical debt of RLP is not eliminated. It is joined by the technical debt of supporting two formats forever. The execution layer becomes a museum of serialization formats, with RLP as the permanent exhibit and SSZ as the new wing.

Competitive Landscape: Blockchain Serialization Formats

The landscape shows that modern chains use static typed serialization. Ethereum's RLP is an outlier. The migration to SSZ aligns Ethereum with industry best practices but carries unique coordination risks due to Ethereum's age and ecosystem size.

Scenario Analysis: Three Futures for RLP to SSZ Migration

Scenario A: Coordinated Success (30% probability)

• All major clients implement SSZ correctly and on schedule
• Testnets identify and resolve edge cases before mainnet deployment
• Rollups and infrastructure providers upgrade within 6 months of mainnet activation
• Performance improvements materialize as predicted
• Ethereum's execution layer becomes cleaner, faster, and more aligned with consensus

Scenario B: Delayed and Fractured (50% probability)

• Client implementation timelines diverge; some clients lag by 6-12 months
• Testnets reveal subtle SSZ parsing differences that require extensive debugging
• Rollup teams push back on upgrade timelines citing engineering resource constraints
• The migration activates on mainnet but ecosystem adoption is incomplete
• Benefits are realized partially but coordination costs exceed expectations

Scenario C: Consensus Incident (20% probability)

• A subtle SSZ parsing difference between clients causes a consensus split on mainnet
• Validators running different clients produce conflicting blocks
• The network halts or forks before emergency patches can be deployed
• The Ethereum community debates whether to roll back or proceed
• The migration is either delayed by years or abandoned entirely

The Bottom Line

EIP-7807 is a proposal whose technical merits are difficult to dispute. RLP is old, inefficient, and type-unsafe. SSZ is modern, efficient, and type-safe. The execution layer should use the same serialization as the consensus layer. The benefits are clear.

But the three traps—consensus splits, ecosystem drag, and historical data burden—are not edge cases. They are predictable consequences of changing a foundational data format in the world's most valuable blockchain. The Serialization Transition Risk Score is 4.55/10. Technical benefit is real. Implementation confidence is low.

The question is not whether SSZ is better than RLP. It is. The question is whether the marginal improvement is worth the risk of consensus failure in a $300 billion network. RLP is ugly but it works. SSZ is elegant but unproven at execution layer scale.

Ethereum has survived for eleven years with RLP. The protocol that prioritizes cleanliness over reliability is not more advanced. It is more fragile. EIP-7807 may be the right long-term direction. But the path from RLP to SSZ is paved with coordination challenges that have broken simpler upgrades in the past.

The developers proposing this understand the risks. They have specified SSZ carefully. They have planned testnets. They have engaged client teams. But specification and execution are different distances on Ethereum. The gap between "correctly specified" and "correctly implemented by five independent client teams" is where consensus splits happen.

TL;DR

• What: EIP-7807 proposes migrating Ethereum execution layer block encoding from RLP to SSZ, aligning execution with consensus layer serialization
• The Score: Serialization Transition Risk Score of 4.55/10—technical benefit (7/10) is real but implementation confidence (4/10), ecosystem coordination (3/10), and rollback safety (4/10) are weak
• The Reality: SSZ offers 15-30% faster parsing, static typing, and native merkleization; but all clients must rewrite block serialization, ecosystem infrastructure must upgrade, and historical data requires permanent dual-format support
• Three Traps: Consensus split (different clients parsing SSZ differently causes network fork); ecosystem drag (rollups, explorers, wallets, indexers must all upgrade on coordinated timeline); historical data burden (RLP blocks remain permanently, creating dual-parser complexity)
• Outlook: Coordinated success (30%) with clean client upgrades and ecosystem adoption; delayed and fractured (50%) with partial adoption and missed timelines; consensus incident (20%) with mainnet split requiring emergency intervention

Sources

• Ethereum Magicians Forum - EIP-7807 Discussion - September 2026 proposal for execution layer RLP to SSZ migration
• EIP-7807 Draft Specification - Technical specification for SSZ encoding of execution blocks
• Ethereum Consensus Layer SSZ Specification - Current SSZ implementation used by consensus layer
• Ethereum Execution Layer RLP Specification - Current RLP encoding documentation
• Ethereum Research Forum - Serialization Format Comparison - Academic analysis of RLP vs SSZ performance and safety characteristics
• Client Implementation Status - Execution Layer - Current client implementation details and coordination status
• Rollup Developer Documentation - Block Processing - How rollup sequencers parse and validate execution layer data
• Blockscout - Ethereum Block Explorer Architecture - How block explorers index and serve execution layer data

Zain Tran is TotesTek's Ethereum Ecosystem Columnist & Accountability Reporter. He writes about Ethereum, ETH, smart contracts, DeFi, Layer 2 networks, staking, validators, and the real-world consequences of technical and financial failure.