Draft. No backwards compatibility. No flag day.
Activated at the genesis of the new final Lux network: **2025-12-25
16:20 Pacific (unix 1766708400)**. The pre-Quasar Edition Lux network
(2020–2025) is a separate network and is out of scope.
LP-208 specifies a DAG of headers — every validator continuously gossips
ZAP-framed block headers referencing K parents from the prior round. The
DAG saturates throughput but is not yet a chain: there are M concurrent
heads at round R, not one. LP-209 turns the DAG into a total-ordered
sequence of blocks for execution.
The mechanism is leader-anchored waves, adapted from Mysten Labs'
Mysticeti for Quasar's cert tiers and the ZAP buffer's MVCC unwind
semantics. Every two DAG rounds an elected leader emerges (VRF or
round-robin over the validator set). The leader's DAG vertex anchors a
wave; the wave commits all vertices in the leader's causal history; the
total order within the wave is a causal sort with a lexicographic
tiebreak on (round, NodeID, headerHash). The LP-217 cert ceremony then
runs on the committed wave as a single QuasarCert event — one cert per
wave, not per header.
The throughput dividend: each wave commits N×K txs (N validators
producing headers × K txs per header), and waves commit at the round
cadence (~50 ms on a LAN), giving ~20 waves/sec at the protocol floor.
With LP-205 pipelining of three waves in flight, aggregate throughput is
3× the per-wave commit rate at unchanged per-wave latency. The latency
dividend: 2 RTTs to wave-commit under <33% byzantine (Mysticeti fast
path), 3 RTTs under <50% byzantine (Mysticeti recovery path), plus the
LP-217 cert mode timing (~5 ms at PQ-strict, ~50 ms at PQ-heavy) for
finality. Total: ~70 ms to PQ-strict finality at LAN scale.
LP-208's DAG vertex is a header — author NodeID, round number, K parent
references, payload commitment. A wave is a commit unit: the set of
all DAG vertices in the causal closure of the anchor (the leader's
vertex). One wave can commit thousands of headers in one step.
The block boundary moves up a tier. A "block" in LP-209's vocabulary is
a wave's committed vertex set, totally ordered by the algorithm below.
LP-210 executes the wave's txs in parallel under Block-STM; LP-217 cert
covers the wave as one unit; LP-211 (cross-shard) coordinates waves
across multiple chain-VMs.
Rounds in the DAG advance at a fixed cadence — every header references K
parents from the prior round (LP-208 §Round structure). Waves are
anchored at even rounds (2, 4, 6, …); leader election runs every 2
rounds.
At even round 2k, the leader is selected via VRF over the round digest:
leader(2k) = argmax_{v ∈ validators} VRF(v.staking_key, round_digest(2k))
round_digest(r) is sha256(chain_id || r || k_prev_round_root). The
VRF is BLS-based (LP-075 BLS leg) for the classical case; under PQ-heavy
the VRF falls back to a Pulsar threshold-derived randomness beacon
(LP-176). Round-robin is the deterministic fallback when no validator
publishes a VRF proof within the round timeout — `leader(2k) =
validators[(2k / 2) mod N]`.
At the end of round 2k+1, every validator examines the DAG and decides:
**did the leader's round-2k vertex receive ≥ 2f+1 references in the
round-2k+1 layer?**
wave covering rounds 2k..2k+2.
The "≥ 2f+1 references" condition is the Mysticeti fast-path quorum
under <33% byzantine. Under <50% byzantine (recovery path), 3-RTT vote
counting on round 2k+2 votes for round-2k+1 votes for round-2k anchors
the wave at the cost of one extra round.
Once the anchor is decided, the wave's commit set is the causal closure
of the anchor in the DAG:
W(anchor) = { v ∈ DAG : v ∈ causalAncestors(anchor) } ∪ {anchor}
\ ∪_{j<k} W(prior_anchor_j)
Subtract prior anchors' commit sets — a vertex is committed exactly
once, by the earliest wave whose anchor causally dominates it.
The wave's vertices are totally ordered by:
1. Round number ascending (vertices in lower rounds order first).
2. Within a round, lexicographic on (NodeID, headerHash) ascending.
This is the canonical sort. Every validator independently computes the
same order from the same DAG — no coordination needed. The order is
deterministic and content-addressable.
Once the wave is ordered, the LP-217 cert ceremony runs on the wave's
ordered byte payload (concatenation of header bytes in order). One
QuasarCert per wave, signed by ≥ 2f+1 validators per LP-182. The cert's
leg composition is per the chain's configured quasar.cert_mode
(LP-217); the cert's blockID field is sha256(wave_ordered_bytes).
LP-208 DAG mempool produces headers (continuous)
↓
LP-209 wave commit (every 2 rounds; leader-anchored)
↓
LP-210 Block-STM execution (parallel; per-tx MVCC; conflict resolution)
↓
LP-217 cert ceremony (one cert per wave)
↓
ZapDB MVCC commit (LP-202 atomic unwind)
Reference numbers from a 40-validator LAN at K=4 parents per header,
T=500 txs per header, round cadence 50 ms.
The 1.2M txs/sec figure is the protocol-floor throughput at LAN scale.
At WAN scale (~150 ms RTT, ~50 ms round cadence held by overlap
gossiping) the wave cadence rises to ~300 ms; aggregate falls to ~400k
txs/sec at 3-deep pipelining — still saturates the LP-210 per-validator
execution budget.
Path to finality for a tx admitted at time t = 0:
End-to-end LAN finality at PQ-strict: ~120 ms. At PQ-heavy: add ~80 ms
for the Magnetar leg (LP-217 PQ-heavy floor) → ~200 ms.
Under <50% byzantine (3-RTT path), add one extra round (~50 ms) → ~170
ms at PQ-strict / ~250 ms at PQ-heavy.
LP-205 specifies block production pipelining — proposer N+1 can build
while proposer N is signing. LP-209 extends this to the wave layer:
Four waves in different stages at any wall-clock moment. The
pipelining-depth cap is the LP-217 cert mode's required-leg slowest
arrival — at PQ-strict ~5 ms is far below the 100 ms wave cadence, so
pipeline depth saturates at the wave cadence itself. At PQ-heavy ~50 ms
is still within the 100 ms cadence, so 2–3 deep pipelining holds. Above
PQ-heavy with very high cert mode latencies the cert-mode timing
dominates; mitigation is to widen the wave window (commit every 4
rounds instead of every 2).
LP-208 produces the substrate; LP-209 consumes it. The contract:
LP-209 never re-orders within a header — the tx order inside one header
is the header author's choice, sealed at LP-208 publish time. LP-209
only orders across headers, by the rule above.
When state is sharded across multiple chain-VMs (LP-204 Tier-2), each
shard runs its own LP-208/209 stack. A cross-shard tx group is committed
atomically by LP-211's cross-shard cert at the parent L1 — the per-shard
wave commits provide each shard's prepare-ack; the parent L1's wave
commits the cross-shard cert.
This means LP-209's "wave" is per-shard; LP-211's "cross-shard commit"
is a parent-L1 wave that references prepare-acks from N shard waves.
The parent L1's wave latency is the max of the per-shard wave latencies
plus the LP-217 cert at the parent L1.
activates: 2025-12-25T16:20:00-08:00
activates-unix: 1766708400
Applies to the wave-ordering layer from the genesis block of the new
final Lux network onward. The pre-Quasar Edition Lux network's serial
block production is out of scope.
leader-election integrity under PQ-heavy)
PQ-fast / PQ-strict modes)
fallback under PQ-heavy)
contract; MVCC unwind on cert failure)
3× throughput)
per-tx parallelism)
composition)