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

After EIP-7975

Who is affected

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.

Original EIP · ← EIPs