Docs Protocol
Hash exchange and attestations
How co-proposers commit to their blocks inside 2δlocal, what an attestation says, and why no proposer gets the last look.
The hash exchange is the one local step New Constellation adds to a slot. Each proposer sends a signed hash of its encrypted block to its co-proposers, waits at most 2δlocal = 20 ms for theirs, and then tells every validator which co-proposers were on time. Its key leaves with that statement, after every block it attests is fixed.
Commitments
The commitment of proposer block b(s,q) is its hash as disseminated, with the payload encrypted:
h(s,q) = h(b(s,q))The commitment also binds the block's key: the header carries H(K(s,q)), so proposer p_q cannot later reveal a different key that opens the same ciphertext to a different payload. The proposer sends it to each co-proposer in the signed message:
Commit(s, q, h(s,q))It goes out together with the last slice of the block, directly to each co-proposer, not through Rotor.
The 2δlocal window
Co-proposers do not start a slot at exactly the same moment: their ParentReady events differ by up to δlocal. So, measured from the moment a proposer sends its own commitment, a correct co-proposer's commitment arrives within 2δlocal: up to δlocal because that co-proposer may have started later, and another δlocal for the message itself.
Every proposer measures the window with its own clock. For each slot s it sets
start[s] = min(time it sends its own commitment,
time it receives the first co-proposer commitment for s)A co-proposer is on time if its commitment arrives by start[s] + 2δlocal, and late otherwise. Since start[s] is never later than its own sending time, a proposer waits at most 2δlocal after sending its own commitment. No clock synchronization is involved: the window starts on a local event and is timed by the local clock.
Redundancy
Slices are erasure coded, and attestations and votes go to all validators, so a few lost messages do not matter for them. A commitment is a single message from one proposer to one co-proposer: if it is lost, the receiver marks an on-time sender late, the attestations disagree and the slot may be skipped. Each proposer sends only k − 1 = 2 commitments per slot, so they are cheap to protect. Acrux sends every commitment several times, a fraction of a millisecond apart; any copy that arrives counts.
The paper also gives an optional second round, in which a proposer forwards every commitment it receives to its other co-proposers. It widens the waiting interval from 2δlocal to 3δlocal. Acrux Net runs with the 2δlocal interval.
Attestations
As soon as the commitments of all co-proposers have arrived, and at the latest at start[s] + 2δlocal, the proposer sends its signed attestation directly to all validators:
Attestation(s, q, π, K(s,q))sis the slot,qthe attester's proposer index.πis the attestation vector, one entry per proposer:π[j] = h(s,j)if the commitment ofp_jarrived on time, andπ[j] = ⊥otherwise. A proposer always counts itself on time.K(s,q)is the key of the attester's own block, revealed here for the first time.
P(π) = { j : π[j] ≠ ⊥ } is the set of proposers an attestation attests. Two attestations agree if they carry the same vector π, the same set and the same commitments.
A proposer never attests before it has sent its own commitment, even when every co-proposer's commitment arrived earlier.
Why nobody sees first
If a block reached its co-proposers in the clear, the slowest proposer could wait, read every other block, and change its own: the last look. Two rules close it:
- Blocks stream out encrypted. Until a proposer receives an attestation, it holds at most another proposer's ciphertext and learns nothing about its payload.
- A key is released only in its proposer's attestation, and that attestation already names the commitments of the co-proposers it accepts. A block can be accepted only together with the blocks whose commitments its proposer attests, and those were all fixed before any payload was revealed.
So a co-proposer that waits to see the others first either committed before it could see anything, or misses the 2δlocal window, is attested late and loses its block. The cost is a few bytes in the attestation and the execution delay of not opening any block before every proposer has committed. See Lemma 2.3 in Guarantees and the Last look scenario.
Timing at the validators
Attestations and keys reach validators at about the same time as the blocks. An attestation waits for the local exchange, at most 2δlocal, and then goes directly to every validator. A block takes Rotor's extra relay hop. As long as 2δlocal ≤ δglobal (20 ms against 250 ms on Acrux Net), the hash exchange adds nothing to the time a validator waits.
What a validator does with attestations
A validator accepts a slot only when every attestation it holds for that slot agrees, the agreed set is a strict majority, and no proposer equivocated. Disagreeing attestations, for example one proposer marking another late, make the validator vote skip; it never votes for a subset of the attested blocks. See Validator.