EIP-7872 Local builder blob cap flag (Max blob flag for local builders)
No call decision · Scaling & data · EIP status Review · created 2025-01-30
Adds a flag letting a local builder that constructs blocks directly set its own cap on the number of blobs included in a block. This is an execution-layer-only change.
Why it is needed
A blob is a large chunk of data that services like rollups attach to a block to post data cheaply. Currently, a builder that constructs blocks directly packs every blob available in its own mempool (the space holding transactions not yet included in a block) up to the protocol's maximum. This is a problem for builders with low internet bandwidth. Including too many blobs can prevent the builder from propagating that data across the network in time, making it unable to prove to the network that the blobs actually exist. This risks having the block it worked hard to build get rejected. This EIP lets the builder set its own blob cap suited to its environment, avoiding this problem.
What changes
Today
- A local builder packs every blob from its mempool into the block up to the protocol maximum
- A low-bandwidth builder may fail to propagate blob data in time
- If blob availability cannot be proven, the block may be rejected
After EIP-7872
- The builder can directly set a per-block blob cap via a configuration flag
- The number of blobs included is limited to whichever is smaller: the protocol maximum or the configured value
- The default can be set to the current fork's maximum, so leaving it unset keeps today's behavior unchanged
Who is affected
- Local builders and node operators: Even with low bandwidth, they can safely build blocks by reducing the number of blobs
- Client teams: Execution-layer clients must add a USER_CONFIGURED_MAX_BLOBS_PER_BLOCK configuration item
- Ordinary users: This is a builder configuration change, not a consensus rule change, so nothing changes from the user's side
In depth
New configuration parameter USER_CONFIGURED_MAX_BLOBS_PER_BLOCK
A parameter called USER_CONFIGURED_MAX_BLOBS_PER_BLOCK is created in the block builder's configuration. The builder uses this value to specify the cap on the number of blobs it will include in a block. According to the source's note, the default can be set to the current fork's maximum. In other words, behavior stays unchanged unless the operator touches it, and the effect only kicks in when it is explicitly lowered.
Minimum rule and zero-value exception
The actual number included is determined as the minimum of MAX_BLOB_GAS_PER_BLOCK and USER_CONFIGURED_MAX_BLOBS_PER_BLOCK. If this minimum is 0, it is changed to 1. The number of blobs to include in the block is then decided based on this value. The source specification defines only these three steps and does not cover details such as the order or priority in which blobs are selected.
An execution-layer-only change, classified as Meta type
The source Abstract states explicitly that this change applies only to the execution layer. Consensus rules and block validity conditions remain unchanged; this change defines configuration behavior on the block-building side. The EIP type is also classified as Meta rather than Standards Track, which governs protocol code changes.
Motivation: data availability failures for low-bandwidth builders
Currently, a builder includes every blob in its mempool up to the protocol-required maximum. If a low-bandwidth builder includes too many blobs, a situation can arise where it cannot convince the network that those blobs are available. Adding the flag lets a local builder specify the number of blobs it can actually handle.
Backwards compatibility and security considerations
The source states that no backward compatibility issues were found. The Security Considerations section is empty, marked N/A. Since this change only adds the builder's own configuration, it has no effect on the validity of existing blocks or transactions.
Current status: Review
This EIP's status is Review. Since the specification is not yet finalized, parameter names and detailed rules may still change. The call records referenced for this explainer contain no fork-inclusion decision for this EIP.