Author: @cskiraly
Thanks to @llewtae for the conversation that prompted this post. A narrower form of the idea is in my early draft Hiding the source of a segmented payload (October 2026): encrypted copies placed on a few nodes before the release, so that the source stays hidden. The form here, for the whole network and for time, first appeared as one line in my Devcon 8 talk, Big Blocks, Quick Slots, Fast Diffusion; this post explains it.
TL;DR
- In Gloas (ePBS), the payload travels only once the builder reveals it. The builder has good reasons to wait after the beacon block, and every moment it waits comes out of the payload’s transfer time.
- Pre-seeding removes that cost: once the block includes its bid, the builder sends the payload encrypted, and the reveal shrinks to a short message with a 32-byte key. The gain is the time from the block’s arrival to the reveal: up to about 3 s on 12 s slots with an early block, little with a late one.
- The price: a builder that only has to send a key can decide later, so its free option to withhold grows. A builder with a private blob can already decide until the later blob deadline, by withholding the blob.
The budget
Gloas fixes the order, beacon block first and payload second, but not when the builder reveals. A payload revealed for a block that is then dropped shows its contents to whoever builds next, so the builder waits until attestations show the block will stay, and long enough to catch a proposer that equivocates; The Glamsterdam equation (2025) models the reveal the same way, as a builder delay after the attestation deadline. An honest builder may also withhold if the block arrived late and is not its head. A member of the payload timeliness committee (PTC) then votes the payload present only if it saw it before half the slot (PAYLOAD_DUE_BPS). Our earlier post assumed a reveal near 3 s, so a budget of about 3 s (Segment, code, push-pull, 2026). Attesters vote as soon as they receive the block, so an early block lets the builder be sure sooner, and a late one, as in timing games, leaves less time to gain.
A fast broadcast fits this budget with room: in simulation, SEACAST, a proposed broadcast protocol, gets 1 MiB, about five times today’s payload, to 99 % of an all-home network in about 0.6 s. The budget binds as payloads grow, slots shrink and uplinks thin: with 10 Mbps uplinks the same 1 MiB takes 1.8 s in that simulation, more than the 1.5 s the same slot fractions would leave on a 6 s slot. Meanwhile, the time between the block and the reveal carries nothing of the payload, which the bid’s block_hash has already fixed.
The idea
- At bid time, the builder compresses the payload, encrypts it under a fresh key, and chunks and erasure-codes the ciphertext.
- Once a valid block includes the bid, it pushes the ciphertext chunks, and nodes check and forward them.
- At the reveal, it sends the key. Nodes check it and forward it at once; with enough chunks, they decrypt and check the envelope as Gloas specifies.
Why encrypt, when the block already commits? The commitment alone does not make plaintext safe: a block can still be dropped until it is attested. Encryption keeps waiting safe: if the block is dropped, the payload’s contents stay private, as an honest builder’s do in Gloas when it withholds. The same encryption keeps, and lengthens, the builder’s strategic option (below).
What changes in Gloas:
- the bid commits to the ciphertext’s chunk root, as EIP-8411 at
41ba25ccdoes to a plaintext one, and to a hash of the key. Withblock_hash, this fixes what the key can open; - a topic for ciphertext chunks, checked against the root and forwarded only once a valid block includes the bid (EIP-8411 at
41ba25ccforwards chunks for any bid accepted on the bid topic), so no losing bid’s ciphertext travels; - a reveal message: the key and the builder’s signature over the key and the beacon block root, both checked before forwarding (the key against its hash); the envelope is encrypted without its
beacon_block_root, as EIP-8411 chunks it; - a PTC member votes the payload present if the key and enough ciphertext reached it before the deadline and decrypt to an envelope that passes its checks; a wrong or missing key counts as a withheld payload;
- after the reveal, a node that missed chunks can request the envelope by its beacon block root, as in Gloas.
Figure 1. The time the payload has to reach the nodes, in one 12 s slot. In Gloas as specified, it runs from the reveal to the payload deadline; pre-seeded, the encrypted payload has from the block to the deadline, and only the key waits for the reveal. The block is drawn at the slot’s start and the reveal at the attestation deadline, as assumed above: the largest gain. A later block, or an earlier reveal, leaves less.
Why not something simpler
Pre-seed k−1 of the parity chunks and send the last one at the reveal. With Reed–Solomon over k data chunks, k−1 chunks cannot be decoded, but at every symbol offset they are k−1 equations in k unknowns: they give away all but one symbol in k, and one correct symbol from any other chunk decodes that offset. Some of what is left is public already, from the bid’s fields to transactions seen in the mempool. Mazorra, Öz, Schlegel and Wu (2025) describe the same move for blob columns, released “just below the threshold required for reconstruction”, as a way to lengthen the builder’s option. A one-time pad cannot help either: it hides perfectly only if it is as large as the payload (Shannon). A key is the computational route, and gives a short reveal.
What it costs
- The builder’s option grows, on one route. Mazorra et al. find that the free option’s value, and how often it is used, grow with the window in which the builder can still decide; shortening the window helps, at a cost to scalability. Their window ends at the latest release of the blobs, whose deadline is later. A key’s time does not grow with the payload, so pre-seeding moves the latest payload reveal later by about the payload’s transfer time less a key’s. The blob route, to three quarters of the slot, is unchanged, and a withheld key keeps the payload hidden where withheld blobs leave it public. Moving the payload deadline earlier would offset the payload route only, and take back as much of the payload’s gain.
- A withheld payload wastes its ciphertext’s bytes at every node, and stays hidden, though its length shows the compressed size; the builder pays its bid only if the block gathers enough attestations.
- Early bytes share the links with the block and the attestations due at a quarter of the slot, so part of the head start can go to them.
Related work
Sending a block encrypted and revealing a short key later is not new: bloXroute (Klarman, Basu, Kuzmanovic and Sirer, 2018) reveals the key once its encrypted blocks have spread, its “minuscule size” letting it “quickly propagate”, to keep its network neutral. In Ethereum, encrypting the payload before its reveal has been proposed to take a choice away: from the MEV-Boost relay (Luhn, 2022; Noyes and Policharla, 2024, whose encrypted block is gossiped with the proposal and opened by the attestations), and from the ePBS builder (Shutter, 2025); Buterin (2022) placed encrypted coded chunks with a committee before the proposal. Per transaction, LUCID (2026) spreads sealed transactions ahead of a key revealed once the beacon block is trusted, and encrypted frame transactions (Thiery, 2026) check such a key against a commitment. Blob Streaming (2026) moves public blob data ahead of the critical path. New here, as far as we found: the whole Gloas payload, under the builder’s own key, spread after the block so that its transfer runs ahead of the reveal, and what that does to the builder’s option.
Open questions
- How much time is gained depends on when nodes hold the block, how long builders wait, and how fast a key spreads; it needs measuring.
- Where the payload deadline should sit once the payload no longer waits for the reveal.
- Blobs and self-builders. Encrypted blob columns would fail the KZG checks, which are against commitments to the plaintext, so blobs need their own answer; a self-builder may not need any of this.
