EIP-8012 Generalized consolidation requests
No call decision · Consensus & staking · EIP status Stagnant · created 2025-08-22
Allows the consensus layer to reinterpret the 48-byte target_pubkey of a validator consolidation request as a generic message. This creates a channel for passing new requests from the execution layer to the consensus layer without changing the execution layer.
Why it is needed
Ethereum is split into an execution layer, which processes transactions, and a consensus layer, which finalizes blocks. A consolidation request works by sending a request to a contract on the execution layer, whose contents are then passed to the consensus layer, but today it is used for only one purpose: merging validator accounts. Adding a new feature to the consensus layer that needs to receive data from the execution layer requires coordinating a hard fork that also changes the execution layer. This EIP proposes leaving the existing consolidation request contract as is, and instead letting the consensus layer interpret the request's 48-byte target_pubkey differently depending on context, so that generic messages can be passed without any execution layer change. The source cites, as a possible use case, an existing validator becoming a builder under EIP-7732.
What changes
Today
- The consolidation request contract is used for only one purpose: validator consolidation
- For the consensus layer to receive a new kind of request from the execution layer requires coordination that changes both layers together
- Even a consensus-layer-only hard fork creates work that is entangled with the execution layer
After EIP-8012
- Generic messages are passed using the same contract, the same calldata, and the same engine API
- If target_pubkey matches the BLS public key of an active validator, it is interpreted as an existing consolidation request; otherwise, as a generic request beginning with MAGIC_PREFIX
- A new request type can be added just by adding a handler on the consensus layer
Who is affected
- Consensus client teams: A branch that separates target_pubkey interpretation and handlers per CALL_TYPE must be added inside process_consolidation_requests.
- Execution client teams: There are no changes to the execution layer or the Engine API.
- Validators and staking operators: Existing consolidation requests work unchanged. In the future, new requests such as an EIP-7732 builder switch can be sent through the same channel.
In depth
Why the existing consolidation request channel is reused
The contract that sends consolidation requests is already deployed, and reusing the same contract, the same calldata, and the same Engine API lets more general messages be sent to the consensus layer without any changes on the execution layer side. The source text cites as the key benefit of this approach that it avoids cross-layer coordination when there is a consensus-layer hard fork. Even when new features are added to the consensus layer, execution clients have nothing to touch.
target_pubkey interpretation rule
This EIP itself does not change consensus-layer behavior; it standardizes how consolidation requests will be handled going forward. When the consensus layer receives a ConsolidationRequest object, it interprets the target_pubkey field in two ways. If the value matches an active validator's BLS public key on the beacon chain, it is interpreted as the target validator for consolidation, as today. If it does not match, those 48 bytes are interpreted as a concatenation of fields for a generalized request. In other words, matching against active validator keys comes first, and generic request interpretation comes after.
48-byte message format
When interpreted as a generic request, the 48 bytes are split in the order |MAGIC_PREFIX | CALL_TYPE | ARG_NUMBER | ARG1 | ARG2 | ARG3 | ARG4 | ARG5|. MAGIC_PREFIX is the 3-byte constant 0xEF0A11 prepended to every generalized consolidation request. CALL_TYPE reads 4 bytes as a little-endian uint32 to identify the function type. ARG_NUMBER is a 1-byte uint8 that records the number of arguments passed to the handler. ARG1 through ARG5 are each read as a little-endian uint64. 3+4+1+8×5 adds up to exactly 48 bytes.
Adding a handler for each new CALL_TYPE
Each time a new CALL_TYPE is added, the consensus layer must add a handler that is called appropriately inside process_consolidation_requests. Deciding which feature rides on this channel is up to whoever defines each CALL_TYPE; this EIP only establishes the framework. The usage example the source text gives is allowing an existing validator to become an EIP-7732 builder.
No changes to the execution layer or the Engine API
No changes are expected to the execution layer, and no changes are needed to the Engine API either. The substantive content of this EIP is only the convention for how the consensus layer interprets the data it receives. The source text states that it is fully backwards compatible and has no known security implications.
Document status
This EIP was proposed by Potuz on August 22, 2025, and its current status is Stagnant. Since progress on the document has stalled, its content may change or be abandoned. No decision has been made on fork inclusion.