Overview: Eliminating Out-of-Protocol MEV-Boost Relay Trust
Since Ethereum's transition to Proof-of-Stake in September 2022, block construction has operated predominantly through Proposer-Builder Separation (PBS) implemented via out-of-protocol software called MEV-Boost. Because Maximal Extractable Value (MEV) optimization requires specialized hardware, private order-flow agreements, and sophisticated simulation engines, over 90% of Ethereum mainnet blocks came to be constructed by a small cohort of specialized external block builders rather than solo validators. To bridge builders and proposers without forcing proposers to trust builders directly, MEV-Boost relies on third-party relays acting as trusted escrow intermediaries: relays verify builder blocks, shield transaction contents until a proposer commits to a header, and guarantee that the proposer receives the promised MEV bid.
While MEV-Boost preserved validator yield parity and kept staking accessible, it introduced a critical dependency outside the Ethereum consensus protocol. Relays are uncompensated centralized servers that can suffer downtime, censor specific transactions, enforce subjective OFAC filters, or fail to deliver valid payloads on time, causing missed slots and liveness degradation. Furthermore, bundling full execution validation inside the 2-second critical attestation path prevented Ethereum from safely expanding block gas limits and blob counts without risking consensus forks among slower home validators.
Selected as the flagship consensus-layer headliner for Ethereum's Glamsterdam network upgrade (pairing the Gloas consensus-layer fork with the Amsterdam execution-layer fork alongside EIP-7928 Block-Level Access Lists), EIP-7732 (Enshrined Proposer-Builder Separation, or ePBS) moves builder separation natively into the core Ethereum protocol. By logically and temporally decoupling consensus block validation from execution payload validation, EIP-7732 eliminates trusted third-party relays, enforces trustless proposer-builder payment settlement on-chain, and stretches the execution validation window across the 12-second slot.
Decoupled Block Production: SignedExecutionPayloadBid and ExecutionPayloadEnvelope
Prior to EIP-7732, every Ethereum BeaconBlockBody bundled the consensus block header and attestations tightly together with the complete ExecutionPayload (all user transactions, state transitions, and KZG blob commitments). Every validating node had to download, validate, and execute the entire payload inside the first few seconds of the slot before casting an attestation.
EIP-7732 breaks this monolithic coupling by splitting block delivery into two separate protocol objects:
- Stripped
BeaconBlockBody: The consensus block removes the heavyExecutionPayloadand blob KZG commitments from its immediate hot path. Instead, the proposer embeds a lightweight builder commitment (signed_execution_payload_bid), attestations from the previous slot's Payload Timeliness Committee (payload_attestations), andparent_execution_requests. - Builder Commitment (
SignedExecutionPayloadBid): Before the slot begins, specialized builders compete in a peer-to-peer bid market by broadcasting signed bid commitments. ASignedExecutionPayloadBidcryptographically binds a registered builder to a specific executionblockhash, the root of execution requests it will produce, and the exact ETH value pledged to the beacon block proposer. - Delayed Execution Broadcast (
ExecutionPayloadEnvelope): Once the proposer selects the winning bid and broadcasts the lightweightBeaconBlock, the winning builder independently propagates the fullSignedExecutionPayloadEnvelopecontaining the actual execution payload transactions, post-state roots, and associated EIP-4844 / PeerDAS blob data.
Because the beacon block itself is compact and contains no heavy transaction execution payloads, consensus proposers and attesters can propagate and verify the chain's consensus skeleton rapidly, even as execution block sizes and blob throughput scale upward.
12-Second Slot Pipelining and Payload Timeliness Committee (PTC) Mechanics
Removing the execution payload from the beacon block creates an obvious coordination challenge: what happens if a proposer includes a builder's winning SignedExecutionPayloadBid, receives consensus attestations for that block, and the builder then fails to reveal the ExecutionPayloadEnvelope (or reveals it too late for blobs to propagate)?
EIP-7732 solves this through deterministic slot pipelining combined with a specialized validator subcommittee called the Payload Timeliness Committee (PTC). Under the Gloas consensus specifications, slot deadlines are calibrated in basis points (_BPS, where 10,000 bps equals 100% of a 12-second mainnet slot, or 1,200 ms per 1,000 bps):
| Slot Phase & Spec Constant | Offset (bps / Seconds) | Primary Protocol Actor & Action | Consensus & Fork-Choice Effect |
|---|---|---|---|
| Beacon Block Proposal | 0 bps (t = 0.0s) |
Assigned Beacon Proposer publishes lightweight BeaconBlock containing SignedExecutionPayloadBid |
Commits the slot to a specific builder's execution blockhash and bid payment |
Consensus Attestation Deadline (ATTESTATION_DUE_BPS_GLOAS) |
2,500 bps (t = 3.0s) |
Slot attestation committees vote on beacon block header and consensus state | Validates consensus head without waiting for heavy EVM execution or blob propagation |
Target Payload Reveal Window (PAYLOAD_DUE_BPS) |
5,000 bps (t = 6.0s) |
Winning Builder broadcasts SignedExecutionPayloadEnvelope and blob sidecars |
Provides network peers time to download transactions and verify data availability |
PTC Timeliness Cutoff (PAYLOAD_ATTESTATION_DUE_BPS) |
7,500 bps (t = 9.0s) |
PTC_SIZE = 512 validators cast PayloadAttestationMessage |
Certifies whether payload and blobs arrived on time; determines Full vs Empty slot status |
| Deferred Execution Validation | t = 9.0s through next slot |
Execution clients validate EVM state transition and apply EIP-7685 requests | Moves heavy state execution off the consensus critical path (~8 to 9 seconds of breathing room) |
The Payload Timeliness Committee (PTC)
In each slot, the beacon chain deterministically samples PTC_SIZE = 512 validators weighted by effective balance from the slot's active committees. Unlike regular attesters who vote at t = 3s on the beacon block itself, PTC members wait until t = 9s (PAYLOAD_ATTESTATION_DUE_BPS = 7500) and cast a PayloadAttestationMessage answering two binary questions: was the builder's ExecutionPayloadEnvelope broadcast before the deadline, and were all committed data blobs available?
Three Fork-Choice Slot States: Full, Empty, and Skipped
Whereas pre-ePBS Ethereum treats every slot as either present or skipped, EIP-7732's LMD-GHOST fork choice distinguishes three distinct slot outcomes:
- Full Slot: The beacon block was proposed on time, the builder revealed the matching
ExecutionPayloadEnvelopebefore the cutoff, and the PTC attested to timely payload and blob availability. The subsequent slot extends the full state transition, executing transactions and withdrawals. - Empty Slot (Beacon Block Without Timely Payload): The consensus beacon block arrived validly, but the builder withheld the payload or failed the PTC timeliness threshold. Consensus does not stall or reorg the proposer's beacon block. Instead, the slot resolves as empty for execution purposes, and the next proposer safely builds on the empty parent variant (
parent_execution_requestsdefaults to empty). - Skipped Slot: No beacon block arrived at all, so LMD-GHOST ignores the slot entirely and builds upon the last canonical block.
Crucially, EIP-7732 applies execution-layer state effects (including transaction execution, withdrawals, and EIP-7685 requests) at the boundary of the next beacon block rather than maintaining parallel execution state trees in memory, avoiding client state-explosion overhead.
Builder Staking, Execution Layer System Contracts, and Trustless Payment Settlement
To enforce fair exchange without relays, builders cannot remain anonymous off-chain actors. EIP-7732 establishes a dedicated builder registry inside the consensus beacon state, cleanly separated from standard 32 ETH consensus validators:
- 1 ETH Minimum Builder Capital Barrier: Unlike validators requiring 32 ETH per key and performing ongoing attestation and sync-committee duties, an entity can register as an enshrined builder with as little as 1 ETH. Builders have no consensus voting duties and are exempt from standard validator activation and churn queues.
- Execution-Layer System Contracts and EIP-7685 Requests: Builders manage deposits, balance top-ups, and exits strictly through two new system contracts deployed on the Ethereum execution layer. State updates submitted to these contracts are routed to the consensus layer via standardized EIP-7685 execution-layer request types.
- Protocol-Enforced Trustless Payments: When a proposer accepts a
SignedExecutionPayloadBid, the consensus layer records a pending payment from the builder's staked balance. Provided the builder's bid satisfied protocol validity checks (and subject to honest-proposer safety rules if a slot collects sufficient attestations), the protocol automatically deducts the bid amount from the builder's beacon balance and dispatches it as an execution-layer withdrawal to the proposer's fee recipient address.
If a builder submits a winning bid but fails to reveal the payload on time, the builder remains liable for the promised bid under builder-withhold safety rules (provided the beacon block gained sufficient quorum support), removing the risk of proposers losing MEV revenue to griefing builders.
Token Economics: MEV Capture, Builder Collateral, and Blockspace Scaling
While EIP-7732 introduces no new asset, it materially reshapes ETH capital efficiency, fee markets, and validator revenue dynamics:
| Economic Dimension | Pre-ePBS (MEV-Boost) | EIP-7732 (Enshrined PBS) |
|---|---|---|
| Builder Collateral Location | Off-protocol trust or external relay collateral | Native beacon-state builder registry (minimum 1 ETH stake) |
| Proposer Payment Guarantee | Reliant on relay solvency and honest accounting | Protocol-enforced deduction from builder balance via EL withdrawal |
| Execution & Blob Window | Tight ~2-second attestation critical path | Expanded ~8 to 9 seconds via deferred validation and PTC cutoff |
| EIP-1559 Base Fee Burn | Constrained by conservative gas/blob caps | Unlocks higher L1 gas limits and PeerDAS blob targets safely |
| Relay Operational Overhead | Uncompensated third-party relay infrastructure | Zero mandatory relay infrastructure for trustless block auctioning |
First, lowering the builder entry stake to 1 ETH alongside protocol-enforced settlement reduces counterparty credit friction. Second, expanding the execution validation window from roughly 2 seconds to nearly 9 seconds enables core developers to raise L1 gas limits and blob targets per block without pricing out residential validators on consumer hardware. Higher throughput directly strengthens ETH fee-burn dynamics under EIP-1559 while preserving decentralized staking participation.
Architectural Comparison: MEV-Boost (Out-of-Protocol PBS) vs EIP-7732 (Enshrined PBS)
The table below summarizes the structural trade-offs between Ethereum's legacy MEV-Boost relay topology and enshrined ePBS under EIP-7732:
| Architectural Criterion | Out-of-Protocol MEV-Boost | EIP-7732 (ePBS in Glamsterdam) |
|---|---|---|
| Trusted Intermediaries | Mandatory centralized relays (Flashbots, bloXroute, Ultrasound, Titan) | None; cryptographic bids and PTC attestations enforced in consensus |
| Block Validation Coupling | Tightly coupled: header, transactions, and blobs validated before slot attestation | Decoupled: consensus block attested at 3s; payload validated after 9s |
| Censorship & Relay Filtering | Relays can unilaterally drop transactions or halt service | Eliminates relay gatekeeping; builder competition happens directly in P2P |
| Empty-Slot Griefing Defense | Handled off-chain via relay reputation and optimistic relaying | Enforced by 512-node PTC timeliness votes and staked builder balances |
| Latency & Spec Complexity | Simple L1 consensus rules; complex external sidecar software | Adds dual-deadline slot logic, fork-choice empty/full branches, and EL contracts |
Objective Risks: The Free Option Problem, Builder Centralization, and Liveness Edge Cases
Despite eliminating relay trust, EIP-7732 introduces subtle game-theoretic and engineering risks documented extensively in Ethereum core research:
- The Free Option Problem: Because a winning builder commits to a
SignedExecutionPayloadBidat slot start (t = 0s) and has until the PTC deadline (t = 6s to 9s) to publish theExecutionPayloadEnvelope, the builder effectively holds an ~8-second financial option. If centralized exchange (CEX) prices move sharply against the builder's CEX-DEX arbitrage trades immediately after slot start, a builder may find it cheaper to forfeit its bid or absorb a fixed penalty than to reveal a losing execution payload. Empirical simulations from Flashbots and academic preprints estimate this option would be exercised in roughly 0.82% of blocks under normal volatility, spiking up to 6% of blocks during extreme market crashes, creating clusters of empty blocks precisely when DeFi liquidations demand maximum throughput. - Builder Market Centralization: Enshrining PBS prevents relay centralization, but it does not eliminate economies of scale in private order flow (exclusive RPCs, Telegram trading bots, and cross-domain MEV integration). A small oligopoly of sophisticated builders can still dominate winning bids unless paired with encrypted mempools or transaction-inclusion safeguards.
- Deferred Censorship Resistance (FOCIL Separation): While ePBS strips relay censorship, builders themselves can still omit transactions from their payloads. Fork-Choice Enforced Inclusion Lists (FOCIL / EIP-7805) was explicitly designed to constrain builder censorship by letting validator committees enforce transaction inclusion, yet FOCIL was deferred from Glamsterdam to the subsequent Hegotá upgrade to contain implementation scope, leaving base-layer inclusion enforcement incomplete until Hegotá ships.
- Split-View and Reorg Edge Cases: Introducing Full and Empty slot branches into LMD-GHOST increases fork-choice complexity. Under adversarial network latency around the 9-second PTC cutoff, builders and proposers could experience timing games or split PTC views if network propagation degrades.
Primary Specifications and Technical References
- EIP-7732 (Enshrined Proposer-Builder Separation): Primary protocol specification defining
SignedExecutionPayloadBid,ExecutionPayloadEnvelope, the 512-member Payload Timeliness Committee (PTC_SIZE), slot basis-point constants, and builder staking rules (eips.ethereum.org/EIPS/eip-7732). - Ethereum Consensus Specs (Gloas Fork): Formal Python reference implementation specifying
ATTESTATION_DUE_BPS_GLOAS,PAYLOAD_ATTESTATION_DUE_BPS, LMD-GHOST full/empty fork-choice rules, and builder registry transitions (github.com/ethereum/consensus-specs). - EIP-7685 & EIP-7928: Complementary execution-layer request framework (EIP-7685) routing builder deposits and exits to the beacon chain and Block-Level Access Lists (EIP-7928) paired with ePBS in the Glamsterdam upgrade.
- Flashbots & Ethereum Research Free-Option Studies: Quantitative analyses evaluating ePBS option exercise rates (~0.82% baseline to ~6% high-volatility spikes) and mitigation proposals such as shortened reveal windows and dynamic non-reveal penalties (ethresear.ch).
Conclusion
EIP-7732 represents Ethereum's decisive transition from patched, relay-dependent block auctions to protocol-native Proposer-Builder Separation. By replacing monolithic block validation with lightweight SignedExecutionPayloadBid commitments, a 512-validator Payload Timeliness Committee, 1 ETH builder staking via execution-layer contracts, and pipelined 12-second slot deadlines, ePBS eliminates trusted MEV-Boost relays while expanding Ethereum's execution and data-availability headroom. While mitigating the ~8-second free option problem and shipping complementary censorship resistance via FOCIL in Hegotá remain vital next steps, EIP-7732 establishes the structural foundation for high-throughput, trustless Layer 1 block production.