EIP-8449 Engine API Proposal Lookahead
No call decision · Networking & nodes · EIP status Draft · created 2026-10-19
Adds an engine API method by which the consensus client informs the execution client in advance of its own validators' block proposal slots and timestamps, fee recipients, and target gas limits. It is a notification that does not start a build, and the execution client uses it to make preparations ahead of time that do not require the parent block.
Why it is needed
Until now, the execution client (EL) has only known that it must build a block when the consensus client (CL) calls engine_forkchoiceUpdated together with payload attributes, and that call starts the build immediately. Because the attributes depend on the parent block, the notification effectively cannot begin until the parent has arrived, and even when the parent arrives on time, only about 8 seconds remain. The CL, by contrast, knows the proposal schedule at least one epoch, or 6.4 minutes, ahead of time thanks to EIP-7917. Preparations that do not need the parent, such as collecting blob data, warming the state cache, pre-executing pending transactions, and rescheduling maintenance, could start much earlier, yet the EL has no knowledge of the schedule. Professional builders who build a block every slot can simply keep doing this preparation at all times, but validators who propose rarely either pay the cost of staying constantly prepared or end up barely prepared at all. Going forward, as EIP-7732, higher gas limits, shorter slots, and FOCIL overlap, the time available after knowing the parent will shrink even further.
What changes
Today
- The EL only knows it must build a block once engine_forkchoiceUpdated arrives, and that call starts the build immediately. In effect, it cannot know until after the parent block has arrived.
- Even when the parent arrives on time, only about 8 seconds remain, and upcoming changes will shrink this further.
- Validators who propose rarely either pay the cost of doing preparation such as blob collection at all times, or end up barely prepared.
After EIP-8449
- The CL informs the EL in advance of the slots and timestamps, fee recipients, and target gas limits at which its own validators will propose in the current and next epoch.
- The EL carries out, minutes in advance, preparations that do not require the parent block, at its own pace and in its own way.
- Starting the build and determining the parent remain, as today, the responsibility of engine_forkchoiceUpdated.
Who is affected
- Validators: Validators can prepare in time for their own proposal slot without having to stay constantly prepared like a professional builder. This makes it easier to keep local building viable on recommended hardware even as the gas limit rises, which underpins censorship resistance by avoiding reliance on external builders for every block.
- Execution client teams: Implementing the method is optional. Implementing it lets clients develop and compete on preparation techniques such as blob collection, cache warming, pre-execution, and maintenance scheduling, each in its own way, without changing the interface.
- Consensus client teams: It is enough to send data the client already has, with roughly one call per epoch. Not implementing it changes nothing.
In depth
The method and the ProposalV1 structure
The new method engine_proposalLookaheadUpdatedV1 takes a single array of ProposalV1 entries. Each entry carries all four fields. slot (QUANTITY, 64-bit) is the proposal's beacon slot; timestamp (QUANTITY, 64-bit) is the block timestamp computed with the slot length that applies to that slot; suggestedFeeRecipient (DATA, 20 bytes) and targetGasLimit (QUANTITY, 64-bit) are the values the CL would put in the payload attributes if that slot were the next slot. The array must be strictly increasing by slot and holds at most 256 entries. The timeout is 1 second, and a successful response is null. With EIP-7917 the CL knows at most 64 proposals at a time, but the upper bound was set at 256 so that a longer lookahead would not require a new version of the method. Timestamps are sent directly rather than derived from the slot because the EL does not know the beacon chain's genesis time and slot length, and EIP-8198 makes the slot length a value that can change across forks.
A notification, not a command
The call is advisory. The EL may ignore the proposal, but it MUST NOT start a build because of this call. As today, only engine_forkchoiceUpdated together with payload attributes determines which parent and which attributes to build with, and if these differ from the notification, the payload attributes take precedence. Each call replaces the EL's entire held set, and an empty array clears the set. Because the full set is sent each time, the call is idempotent, so if the CL calls it again after a restructuring, a restart, or a failed call, the state is corrected. The EL replaces the set only after validating the entire request, and leaves the set unchanged when returning an error. Exceeding 256 entries returns -38004 (Too large request); missing fields, malformed data, or a slot or timestamp that is not strictly increasing returns -32602 (Invalid params). When multiple CLs share one EL, only the CL that calls engine_forkchoiceUpdated may call this method, and a CL must not include proposals for validators it does not run.
Preparations the EL can make in advance
In the sparse blob pool (EIP-8070), a node fully receives only some blob transactions and samples the rest, but putting a blob transaction into a block requires the full blob. EIP-8070 has the local builder receive the full blob at all times, which is about 4 times the bandwidth of a sampling node, and switching 2-3 slots before building is discouraged because it reveals a pattern. With a notification minutes in advance, the switch can happen at a randomized time. Other preparations include pre-loading into cache the state that pending transactions will read, pre-executing with the notified timestamp, fee recipient, and gas limit and reusing the result only if the dependencies still hold, moving maintenance such as database compaction and history pruning away from the slot, and reducing one's own gossip around the slot to free up uplink for blocks and data columns (EIP-7594). The EL SHOULD bound the resources used for preparation, ensure preparation does not delay block import or other engine API responses, start any externally observable preparation at a randomized time, and avoid exposing proposals through public RPC, metrics, or logs.
Background: the shrinking timeline
Under EIP-7732 (ePBS), the execution payload is revealed after the beacon block, in the middle of the slot, so the time between a parent that arrives on schedule and the next slot shrinks from 8 seconds to 6 seconds. The gas limit has risen to 60M (EIP-7935), core developers agreed on 200M at Glamsterdam, and Sepolia, where Glamsterdam activated in October 2026, now runs at about 200M. Block-level access lists (EIP-7928) let validators execute in parallel, but builders still have to find dependencies themselves, so as the limit rises, building can become a bottleneck for local builders on EIP-7870 recommended hardware. EIP-8198 (Quick Slots), under review at Hegotá, proposes cutting the slot from 12 to 8 seconds (the current consensus spec draft has 10 seconds), and EIP-7782 proposes cutting it to 6 seconds, while fixed costs such as disk and network latency do not shrink along with it. Under FOCIL (EIP-7805), planned for Hegotá, the inclusion list from the previous slot arrives by the 9-second mark of that slot, so a proposer building directly can only receive it 3 seconds before the payload is due. Because the list comes from the public mempool, an EL that has pre-prepared the mempool has little left to do.
How this differs from engine_preparePayload
In an early engine API draft, engine_preparePayload was a method that took a parent block hash and started a build on top of that parent; because a build started by a separate call could conflict with a fork-choice update designating a different head, it was folded in 2021 into the optional payload attributes of engine_forkchoiceUpdated. That problem arose from specifying a parent and starting a build. This method carries only values that are already fixed before the parent exists, and it is a notification that does not start a build, so there is nothing for it to conflict with in fork choice. The reason the EL is not made to query proposal duties directly from the beacon node is that only the CL and the validator client know which validators are being serviced, and the CL already tracks changes from dependent-root changes or from validators being added or removed. The fee recipient and gas limit are values that already flow from the validator client to the beacon node via the beacon API (proposer preparation, validator registration, and, from Gloas onward, signed proposer preferences), so there is nothing new to compute.
Optional on both sides
Support is optional on both the EL and CL side and is not tied to a fork. An EL that implements it MUST include it in the method list exchanged via engine_exchangeCapabilities, and a CL MUST NOT call an EL that does not list it. The CL SHOULD call it at startup, after the exchangeCapabilities exchange, at least once per epoch, and whenever the proposal changes (dependent root change, validator addition/removal, change of fee recipient or target gas limit). If either side does not implement it, nothing changes, and a failed call must not affect the CL's other engine API usage. There is precedent for this: engine_forkchoiceUpdatedV4 already passes custodyColumns for the sparse blob pool, and engine_getBlobsV1 was introduced after Cancun independent of any fork.
Security: privacy, DoS, correctness
The EL learns several minutes in advance when its own validator will propose. An EL run by the same operator would learn this a few seconds in advance anyway through the payload attributes, but a remote or shared EL, or anyone reading engine API traffic that is authenticated with JWT but not encrypted, can also learn it. Since the proposal duty itself is public, what this exposes is which node runs that validator, and that becomes a lead for targeted attacks. Preparation that peers can observe, such as collecting the full blob set or a change in gossip behavior, carries the same risk, so the specification requires randomized start timing and that the information not be exposed through public RPC, metrics, or logs. For DoS, only an authenticated CL can call it, requests are capped at 256, and the only damage a misbehaving CL can cause is wasting preparation resources that the EL itself bounds. For correctness, the call cannot change what the block is built on, and prepared results are only used when what they depended on still holds for the actual parent and payload attributes, a check that is the EL's responsibility.
Current status
This EIP was created on October 19, 2026 and is in Draft status. The specification, numeric values, and error codes may change during discussion. There is no core developer call decision yet on whether it will be included in a fork, and the method itself is designed not to be tied to any fork.