NETSoon

Docs Protocol

Proposer schedule

Algorithm 3. Hubs, proposer stake and its cap, which hubs are active, how windows go to hubs, and how the k proposers of a window are drawn.

The proposers of a window must reach each other within δlocal, so they are always drawn from one hub: a group of co-located validators, such as those in one city. The schedule of an epoch does two things. It gives every window to an active hub, and it draws k = 3 distinct members of that hub as the window's proposers.

Hubs

Hubs are not planned. A hub forms wherever enough validators gather and disappears when they leave; the protocol only sets the conditions under which a hub takes part in the schedule.

  • Registration. Anybody registers a hub with an on-chain transaction, under a unique name (an airport code such as FRA) and a location given as an integer ECEF coordinate triple, as in SIMD-0674. Registering takes a deposit, and the name is released if the hub stays inactive too long. A new hub is pending until enough validators join it.
  • Joining. A validator joins a hub by name with an on-chain transaction. Leaving and moving are transactions too. Every change takes effect at an epoch boundary announced in advance, so schedules are fixed ahead of time, and a cooldown stops validators hopping between hubs. A validator in no hub only votes.

On Acrux, hubs are registered and joined in the Hub Registry program on Solana mainnet. Its accounts, instructions, deposit, fee, cooldown and inactivity period are in Hub Registry program; the operator's path is Join a hub.

Proposer stake

Let σ_i be validator i's stake as a fraction of the total. Its proposer stake σ̂_i decides how often it is drawn. A validator outside every active hub has σ̂_i = 0. A hub member normally has σ̂_i = σ_i, unless it is too large for its hub: a window needs k distinct proposers, and one member can fill only one of the k roles however much stake it holds.

Sort the members of hub h by stake, σ_1 ≥ σ_2 ≥ … ≥ σ_n, with n ≥ k. For j = 0, 1, …, k − 1:

text
c_j = (σ_(j+1) + … + σ_n) / (k − j)

the stake of all but the j largest members, spread over the remaining k − j roles. The cap c is c_j for the smallest j with σ_(j+1) ≤ c_j; such a j always exists, at the latest j = k − 1. Then:

text
σ̂_i = min(σ_i, c)          proposer stake of member i
σ̂_h = σ̂_1 + … + σ̂_n = k·c  hub stake

The j largest members are capped at exactly 1/k of the hub stake and are proposers in every window of the hub. The other k − j roles of every window are drawn among the remaining members in proportion to their stake. Stake above the cap still counts for voting and rewards, not for proposing.

Example. k = 3, members with 6%, 2%, 1.2% and 0.8% of total stake. c_0 = 10% / 3 = 3.33%, and 6% exceeds it. c_1 = 4% / 2 = 2%, and the second member's 2% does not exceed it, so c = 2%. Proposer stakes are 2%, 2%, 1.2% and 0.8%; the hub stake is 6%. The two largest members propose in every window; the third role goes to the 1.2% member in 60% of windows and the 0.8% member in 40%.

A large validator gains nothing by concentrating its stake in one hub, and gains proposer roles by splitting it across hubs in different regions.

Active hubs

A hub h is active if:

ConditionOn Acrux
(i)at least n_min ≥ k membersn_min = 4
(ii)hub stake σ̂_h ≥ ρ_minρ_min = 1% of total stake
(iii)its members reach each other within δlocalenforced by attestations

Condition (iii) needs no registry check. A fast hash exchange proves to each proposer that the other is close, since no message travels faster than light, and a member that cannot keep up is marked late by its co-proposers and loses its blocks.

Windows to hubs

If windows went to hubs in proportion to hub stake alone, one large hub could take the schedule. Instead each window goes to a hub in proportion to hub stake with probability α, and to an active hub chosen uniformly otherwise. Acrux uses α = 1/2. A hub holding fraction x of all hub stake gets

text
π_h = α · x + (1 − α) / |H|

of the windows, where H is the set of active hubs. Stake in a large hub earns fewer proposer roles per unit than stake in a small one, so no hub dominates and validators have a reason to join smaller hubs. Since every active hub gets at least (1 − α)/|H| of the windows, n_min and ρ_min must keep that share from being cheap.

Regional runs

The drawn windows are reordered in the manner of SIMD-0675, with hubs in the role of leaders: each region's windows stay together as one run of consecutive windows, in their seeded draw order, and the schedule moves from region to region. A handover within a run costs a few milliseconds; one between regions costs what a handover between distant leaders costs in Alpenglow.

Proposers of a window

For each window, the members of its hub are placed in random order on a line of length σ̂_h = k·c, member i covering an interval of length σ̂_i. With a uniformly random offset u in [0, c), the proposers are the members whose intervals contain the k points u, u + c, …, u + (k − 1)c, and their proposer indices are assigned at random.

No interval is longer than c, so the k proposers are distinct. Member i is a proposer with probability exactly σ̂_i / c: a capped member in every window of its hub, every other member in proportion to its stake.

Determinism

Every draw uses a deterministic PRNG seeded from the epoch. Stakes and hub memberships come from the same snapshot as the leader schedule, so every validator computes the same schedule. Acrux's node and its API compute the schedule through one code path, checked by a shared fixture; the preview of the next epoch is on /hubs.

Algorithm 3

Proposer schedule of an epoch with N windows.

text
Require: active hubs H; proposer stakes σ̂_i and hub stakes σ̂_h; PRNG seeded from the epoch

 1: π_h ← α · σ̂_h / Σ_(g∈H) σ̂_g + (1 − α) / |H|      for all h ∈ H     hub schedule
 2: for i = 1, …, N do
 3:   h_i ← random hub from H, hub h with probability π_h
 4: end for
 5: (h_1, …, h_N) ← SIMD-0675(h_1, …, h_N)              reorder, hubs as leaders
 6: for i = 1, …, N do                                  proposers of window i
 7:   (m_1, …, m_n) ← shuffle(members of h_i); c ← σ̂_(h_i) / k
 8:   u ← uniformly random in [0, c); s ← 0; W_i ← ()
 9:   for j = 1, …, n do                                m_j covers [s, s + σ̂_(m_j)); next point is u
10:     s ← s + σ̂_(m_j)
11:     if u < s then append m_j to W_i; u ← u + c
12:   end for
13:   W_i ← shuffle(W_i)                                proposer indices
14: end for
15: return (W_1, …, W_N)

Acrux Net's hubs

Acrux Net runs three genesis hubs, FRA, NYC and TYO, with four validators each. Within a hub, links run within δlocal; between hubs, each link carries the delay of the distance between the cities. Each window's three proposers are drawn from its hub's four members by Algorithm 3. The live schedule ahead is on /net.