EIP-7975 eth/70 partial block receipt lists (eth/70 - Partial Block Receipt Lists)
No call decision · Networking & nodes · EIP status Last Call · created 2025-06-16
Adds a chunked-delivery capability to the p2p protocol nodes use to exchange block receipts. Defines a new version, eth/70, that allows receipts to be received across multiple messages when they are too large to fit in one.
Why it is needed
Ethereum is moving toward raising the per-block gas limit. As blocks grow larger, the overall size of the receipts, the records of how the transactions in that block were processed, grows along with them. However, nodes typically do not accept p2p messages larger than 10 MiB, since a message can only be determined to be valid once it has been fully received, so oversized messages are rejected outright. If the gas limit rises high enough, a single block's receipt list could exceed this limit, which could cause sync to fail for nodes newly joining and downloading historical data. This EIP preempts that problem by defining a way to exchange receipt lists across multiple messages.
What changes
Today
- A single block's receipt list MUST currently be received entirely within one message
- As the gas limit rises, receipt lists exceeding the 10 MiB message limit could cause sync to fail
- Receipt lists are validated by matching the whole list against the value recorded in the block header
After EIP-7975
- Large receipt lists can now be received split across multiple messages
- A new flag indicates whether a response was truncated, and a truncated block's receipts can be requested again as a continuation
- Separate validation rules checking count and size are applied to partial lists received this way
Who is affected
- Client teams: A new protocol version, eth/70, must be implemented. It can run alongside the existing eth/69, so older clients are not immediately disconnected.
- Node operators: This avoids sync being blocked by receipt size even as the block gas limit rises.
- Ordinary users: There is no directly perceptible change. Consensus rules and the EVM are unchanged, and no hard fork is required.
In depth
Adding lastBlockIncomplete to the Receipts (0x10) message
The eth/69 encoding for Receipts is [request-id: P, [[receipt1, receipt2], ...]]. In eth/70, this changes to [request-id: P, lastBlockIncomplete: {0,1}, [[receipt1, receipt2], ...]]. If lastBlockIncomplete is 1, it means the last receipt list in the response does not contain all of that block's receipts, and the client must obtain the rest via a new request.
Adding firstBlockReceiptIndex to the GetReceipts (0x0f) message
The eth/69 encoding for GetReceipts is [request-id: P, [blockhash1: B_32, blockhash2: B_32, ...]]. In eth/70, firstBlockReceiptIndex: P is inserted after request-id. For the first block in the requested list of block hashes, the server omits from the response the receipts up to firstBlockReceiptIndex. This allows continuation from the point where it was truncated.
Three validation checks applied to partial lists
Receiving receipts split across multiple messages creates a new attack surface. Since a partial receipt list cannot be validated against the block header, the last receipt list in a response with lastBlockIncomplete = 1 must be validated by other means. First, check that the total number of receipts received matches the number of transactions. Second, compare each receipt's size against the gas limit of its corresponding transaction and reject it if it exceeds gaslimit/8. Third, check that the total size of the downloaded receipts does not exceed what the block gas limit allows.
Why it can exceed 10 MiB
EIP-7825 caps a single transaction's gas limit at about 16.7M, so the receipt size of any single transaction is always bounded. Specifically, the maximum log data a single transaction can produce is 16777216/8 = 2 MiB. However, since a block contains multiple transactions, the receipt list for the whole block can be much larger. At a block gas limit of about 83M, the Receipts message can exceed 10 MiB. Since clients can only determine validity once a message has been fully received, they typically reject messages beyond this size.
Buffering before validation is unavoidable, but its size is bounded
The block receipt list in a Receipts message is validated by matching the entire list against the tree root stored in the block header. When received across multiple requests, the client may need to buffer more than 10 MB of unvalidated input. At a high block gas limit, the protocol allows receipt lists of that size, so this itself is unavoidable. Instead, applying the count and size checks from the specification places an upper bound on the input size.
Backward compatibility and rollout
Since this EIP changes the eth protocol, a new version, eth/70, must be deployed. Because the wire protocol can support multiple versions simultaneously, older clients can keep using eth/69 even after the new version is released, and they are not disconnected immediately. The EVM's consensus rules are unchanged, and no hard fork is required.
Progress status
This proposal is at the Last Call stage, with a deadline of 2026-11-01. Last Call is the final comment period before finalization, so details may still be revised before it is finalized. The available material contains no record of a fork-inclusion decision at a core developer call.