EIP-8408 eth/73 indexed cell requests (eth/73 - Indexed Cell Requests)

No call decision · Networking & nodes · EIP status Draft · created 2026-09-01

A proposed eth/73 network protocol extension that adds an index format to the GetCells and Cells messages used to fetch blob cells, allowing a different cell mask to be used per transaction.

Why it is needed

The current eth/72 GetCells message applies a single cell mask uniformly to every transaction hash in a request. If different transactions need different cells, a node has to split the request into multiple requests, grouping together only those with the exact same mask. When responses come back partial, or peers hold different data, transactions end up missing different sets of cells. Conversely, if each transaction carries its own mask, there is no need to split, but a 16-byte mask repeated for every hash makes the common case, where all masks are the same, larger. This EIP avoids the downsides of both approaches by listing each unique mask once in a table and having each hash point to that table's index. The existing shared-mask format is kept as is, so there is no added overhead in the common case.

What changes

Today

After EIP-8408

Who is affected

In depth

eth/73 and the two message formats

eth/73 extends eth/72 as defined by EIP-8070, and apart from the indexed format added to GetCells (0x14) and Cells (0x15), all messages and semantics remain unchanged. The shared format for GetCells is [request_id, [hashes...], cell_mask], and the indexed format is [request_id, [hashes...], [mask_0, mask_1, ...], mask_ids]; the two formats are distinguished by RLP list length. In an indexed request, the mask that mask_ids[i] points to specifies the cell indices requested across all blobs of the transaction at hashes[i]. A mask is B_16 (16 bytes), a hash is B_32, and a cell is B_2048.

Validity rules for the mask table

An indexed message consists of a list of unique masks, masks, and a 1-byte index per hash, mask_ids, and must satisfy all eight requirements: 1 to 64 transaction hashes; len(mask_ids) equal to the number of hashes; 1 to 64 masks; all indices less than len(masks); every mask referenced at least once; no duplicate masks; masks arranged in the order they are first referenced in mask_ids; and hashes must be unique within the message. If any requirement is violated, the recipient must treat the message as invalid. The 64-hash figure that was a recommendation in eth/72 becomes a mandatory limit in the indexed format, with a separate limit of 64 masks added. Because the index is 1 byte, future versions can raise the table limit up to 256 without changing the encoding.

Rules for choosing the request format

The sender follows three selection rules. If all hashes use the same mask, it MUST use the shared format. If a single scheduling batch has multiple masks, it MAY choose either to split the batch into shared requests or to send an indexed request. The indexed format SHOULD be used only when it reduces the number of requests or the total encoded size. Keeping the shared format as the default is meant to avoid regressing the common case, since custody-aligned sampling typically produces a single shared mask across many transactions.

Rules for indexed responses

A response must use the same format as the request. Since the eth/72 Cells response can only carry a single shared mask and cannot express a different returned cell set per transaction, an indexed request must be followed by an indexed response. An indexed response may omit some hashes or cells under eth/72's existing response-size and serving-capacity rules, and masks and mask_ids must describe only the data actually included while still satisfying the mask table requirements. Each transaction's response mask must be a subset of the requested mask, and cells are ordered by the transaction's blob order, then by ascending cell index among the set bits of the response mask. An indexed response with no data is encoded as [request_id, [], [], [], empty mask_ids], and empty indexed requests are prohibited.

Resource limits and security considerations

An implementation must validate the number of transactions, number of masks, indices, and canonical ordering before allocating storage for cell responses. Indexed requests and shared requests must be counted against the same per-peer request and response quotas, and an indexed request must not receive a larger quota than the equivalent shared request would. eth/72's soft response limit continues to apply, and a responder may reduce the response independently per transaction, as long as the response mask remains a subset of the requested mask. From a privacy standpoint, per-transaction masks reveal more about what the requester is missing, so shared requests are recommended for routine custody sampling, and indexed requests should be used only when there is a benefit from heterogeneous recovery state. All cells and proofs must be cryptographically verified against the transaction's commitment.

A conditional optimization not yet validated

In synthetic request traces, the request frame shrank significantly for heavily fragmented batches, but one sparse devnet observation found no fragmented batches at all among 92 scheduling batches in the measured window. The source text states explicitly that this EIP is a draft for evaluating a conditional optimization, not a claim that current network traffic requires a new protocol version. Implementers should collect the number of mask groups, hashes per group, request frames, response frames, and end-to-end latency before recommending eth/73 deployment.

Draft status and backward compatibility

This EIP is in Draft status, created on September 1, 2026, so the specification may still change. Since eth/73 is a newly negotiated eth capability, nodes implementing it can continue to negotiate eth/72 with peers that do not support indexed cell requests, and such peers will receive only the shared format defined by EIP-8070. This is a networking-layer proposal unrelated to a hard fork, and there has been no core developer call decision yet on whether to include it in a fork.

Original EIP · ← EIPs