On this page
- §0 The area in one paragraph
- 1. The selection generator and the active and selectable sets
- 2. Rounds, targets and windows
- 3. Priority, position and the empty-block rule
- 4. Producing a block
- 5. Skipped blocksmiths
- 6. Difficulty and cumulative difficulty
- 7. Who earns, and the production set
- 8. The consensus/local split
20 — Blocksmith selection and timing
Out of scope the block seed's bytes and its VRF proof (05 §5, 01 §8); the validator's use of these rules (19 §2–§3); the participation score, the score road, suspension and expulsion (36); the blocksmith's reward and the coinbase lottery (21); the node registry's admission cycle, queue, exit hold and roll-call transaction (09); receipts (23); the spine chain's own production (25); the full schema of the registry tables (07)
§0 The area in one paragraph
Who may attach the next block, and when, follows from the previous block alone. Its seed
feeds a deterministic generator whose successive draws name a node of the selectable set:
the registry active at the previous height, ordered by node id, minus the nodes suspended by the
liveness rule (36), and, in blocks 2 … roll_call_blocks of a new chain, minus the genesis
registered nodes that have not answered the roll call (09). The previous block's blocksmith is demoted,
not removed: its draws in rounds below max_priority_blocksmiths (10) count as round 10, so it can
make two blocks in a row only when nobody else answered nine rounds, and a lone survivor keeps the
chain going (one block per 150 s). Draw 1 is round 1, draw 2 round 2, and so on; a round opens 15
seconds after the previous round's target and a blocksmith drawn in it stays acceptable for that
round and the next. A node drawn in an open round builds a candidate stamped at the round's
target, makes the new seed as a VRF proof over the previous one (05), and broadcasts the
candidate no earlier than its position allows; the lowest round wins the slot (19 §5), and a
blocksmith at position 10 or later must leave the block empty. It never signs two blocks over one
parent (one more only past the recovery limit). Every node drawn before the eventual blocksmith is a
skipped blocksmith: it is recorded, and it becomes missing on the score road (36) until
its next own block. The block's difficulty increment is the chain's divisor (a million)
divided by the blocksmith's rank in the draws over the draw set, scaled by the draw set's share of
the registry and floored at the round the timestamp falls in, which makes the heaviest chain the one
produced closest to the top of each round. Everything here is integer arithmetic on data every
node holds.
1. The selection generator and the active and selectable sets
Purpose. An implementation must produce the same draws and the same ordered node lists as every other node, because every mechanism below reads them.
Inputs. The previous block P (its block_seed, 64 bytes; its height; its blocksmith key); the
registry (node_registry, 07/09); the liveness rows (36); the roll-call answers (RollCall
transactions in blocks, 09); roll_call_blocks (20 in both genesis files; at least the builder's
minimum); max_priority_blocksmiths (10; the genesis builder requires 1 … LIVENESS_STALL_ROUNDS
10); the rules liveness_miss_rule, resume_by_queue.
Data. The registry is versioned by height: each change of a node writes a new row (node id,
public key, owner account, status, registration height, …); the row of node id i as of height
H is the newest row of i with row height ≤ H. A row with status Registered is active. The
active set at H = every node whose row as of H is Registered, ordered by node id ascending
(signed 64-bit compare). Genesis rows have row height 0 and count at every height.
Output and effect.
- The generator
RNG(prefix, seed):h = SHA3-256(prefix ‖ seed);v= the unsigned 64-bit integer read big-endian fromh[24..31]; a Splitmix64 with statevproducess0thens1(each step:state += 0x9E3779B97F4A7C15;z = state;z = (z ⊕ (z ≫ 30)) × 0xBF58476D1CE4E5B9;z = (z ⊕ (z ≫ 27)) × 0x94D049BB133111EB; outputz ⊕ (z ≫ 31); all arithmetic mod 2⁶⁴); then xoroshiro128+ on (s0, s1):out = s0 + s1;s1 ⊕= s0;s0 = rotl(s0, 24) ⊕ s1 ⊕ (s1 ≪ 16);s1 = rotl(s1, 37); each draw isout ≫ 1(a non-negative 63-bit value). The selection prefix is the 14 ASCII byteszbc-blocksmith. Draw k names indexdraw_k mod nof a list of n nodes. - The selectable set (the draw set) for the block after P: the active set at P's height
minus the nodes with a suspension in force at P's height (
36; when that removes every node, the whole active set); a failed read of the suspended nodes fails the draw. A suspended node returns only by its own block or by a ping (a QueueAttendance from that node dated at its reference block,09§7); a receipt never brings it back. - The roll call (no rule): for a block at height h with 2 ≤ h ≤
roll_call_blocks, when at least one genesis registered node (a row with registration height 0) has answered and 2 × answered ≥ the number of genesis registered nodes, every genesis registered node whose RollCall is in no block below h leaves the set (a registered node answering in block k is drawable from k + 1); newcomers stay; when that would empty the set it is kept whole. Block 1 is drawn over every registered node. A registered node in its exit hold (09§5) is still Registered and stays drawable until the leave step removes it. - The previous blocksmith stays in the set, demoted: with F =
max_priority_blocksmiths(1 when the parameter is below 1), its draws in rounds below F count as round F (its effective round ismax(r, F)); its later draws are ordinary. - When every active node is suspended and the block's gap exceeds the recovery limit, the best node
of the attended queue (
09§9/§10 order) is appended as a resume candidate (ruleresume_by_queue).
How to compute it. As stated; the modulus is taken of the non-negative draw.
Rule activation. liveness_miss_rule, resume_by_queue: active from height 0 on every
chain. The demotion and the roll call have no rule.
Rejections and errors. An empty set → "No nodes available"; a block over it cannot be
validated (19 §2 step 6).
Vector. computed. INPUT: seed = 64 zero bytes. EXPECTED: h =
2a857d6a57d30f1c54e946a692555aa9f79dabe5790ebd52902868ff55bb9fb4, v = 902868ff55bb9fb4, s0 =
0x44bbb386f849d2b2, s1 = 0xe5fdda30b2bf69c6; draws 1 … 5 = 1,539,323,820,136,242,748;
6,228,456,926,691,826,632; 8,358,880,366,061,543,320; 6,634,008,734,580,907,768;
1,010,366,185,480,732,819 (mod 11: 3, 3, 2, 0, 2). computed. INPUT: the seed S of a
previous block,
47acf77aa182eba5b0bed7c450dff155999937b54364a52cd0e80ad7d1c235a0d55d14a03a16227f9f387b00186fb4bb814bdfc37f55d785fd177f0f77acd498;
a draw set of 11 registered nodes, none suspended, by node id ascending: 88,697,328,554,714,370 (02a50719…),
1,417,521,806,099,974,635 (eb89f581…), 1,590,136,471,457,360,039 (a7e89b25…),
3,219,899,983,035,352,172 (6cc41b8d…), 3,715,018,299,146,412,646 (66a2b2c6…),
4,016,115,710,591,262,321 (715ea8e2…), 4,832,784,384,054,893,163 (6b9aa5c7…),
4,933,499,001,599,987,543 (578f1c02…), 5,679,266,776,148,337,025 (81e1fff8…),
6,491,144,547,391,062,772 (f442f504…, the previous blocksmith, demoted), 9,161,275,597,898,082,805
(f5692b26…). EXPECTED: h = 1d3c0a7cce91e666cf69494b671f9b662d405e41699d030c79f2f261c4ea3d49,
v = 79f2f261c4ea3d49, s0 = 0x80e9fae3ef5169aa, s1 = 0x86638c6b0be50ca7; draw 1 =
263,112,752,382,032,680, mod 11 = 6 → 6b9aa5c7ca7f11c32b3bc6e006571319a7521aaa472f3c422f52626e48c3833e
is round 1's blocksmith; draw 2 = 1,530,434,952,209,116,937 (mod 11 = 5 → 715ea8e2…); draw 3 =
4,671,832,841,340,716,915 (mod 11 = 6 again). INPUT (roll call, 11 genesis registered nodes,
roll_call_blocks 20): only block 1's blocksmith answered in block 1. EXPECTED: block 2 is drawn
over all 11 (1 answered, 2 × 1 < 11); with 6 answered in blocks 1 … 4, block 5 is drawn over
those 6.
Test cases · §1
7 cases · 6 valid · 1 invalid
The selection generator over a seed of 64 zero bytes
Loading the test widget…
The generator over the seed S of a previous block
Loading the test widget…
Draws 1 and 2 over seed S and eleven registered nodes name the blocksmiths of rounds 1 and 2
Loading the test widget…
Roll call: one registered node of eleven answered, block 2 is drawn over all eleven
Loading the test widget…
Roll call: six registered nodes answered, block 5 is drawn over those six
Loading the test widget…
Past roll_call_blocks the roll call no longer restricts the draw
Loading the test widget…
An empty draw set is refused
Loading the test widget…
Defects to match. (1) A one-node chain produces only at round 10 (every draw names it, and it is its own previous blocksmith): one block per 150 s. (2) Registry rows at height 0 count at every height; the set is read by row height, not by registration height.
2. Rounds, targets and windows
Purpose. An implementation must derive the same time structure of one height from the previous block's timestamp.
Inputs. The previous block's timestamp P; min_block_interval 15, blocksmith_time_gap 15,
blocksmith_block_creation_time 15, blocksmith_network_tolerance 5, smithing_period 15 (all in
both genesis files).
Output and effect. base = P (rule smith_window_anchor). For round r ≥ 1: target_r = base + 15 + 15 × (r − 1); the persist window [max(target_r − 7, P + 1), target_r + 7); the creation
window [max(target_r − 7, P + 1), target_r + 7 + 20). A block timestamp T has round 1 + floor((T − base − 8) / 15) when T − base − 8 ≥ 0, else 1. A blocksmith drawn in round i may validly
produce a block of round r when i ∈ {r − 1, r} (the last 1 + floor(20 / 15) = 2 rounds) and T lies
in round i's creation window (19 §3). The skipped-blocksmith list (§5), the validity (19 §3) and
the difficulty (§6) all use this one round formula (rule one_round_formula).
How to compute it. Integer arithmetic; the half gap is 15 div 2 = 7.
Rule activation. smith_window_anchor, one_round_formula: active from height 0 on every
chain.
Rejections and errors. 19 §2 step 5.
Vector. computed. INPUT: P = 1,793,713,987. EXPECTED: round 1 target 1,793,714,002,
persist [1,793,713,995, 1,793,714,009), creation [1,793,713,995, 1,793,714,029); round 2 target
1,793,714,017, persist [1,793,714,010, 1,793,714,024). T = 1,793,714,002 (P + 15) → round 1. T =
P + 37 → round 2 (floor(29 / 15) = 1). T = P + 38 → round 3.
Test cases · §2
1 case · 1 valid
Targets and windows of rounds 1 and 2 after P = 1,793,713,987
Loading the test widget…
Defects to match. None.
3. Priority, position and the empty-block rule
Purpose. An implementation must give each blocksmith the same position, because the position decides whether its block may carry transactions.
Output and effect. A blocksmith's position (0-based), as the validator computes it, is the
index of the first draw naming it among the first 2n draws, n the size of the draw set (the demoted
previous blocksmith's position is floored at F − 1 = 9: position 9 is round 10, the last whose block
may carry transactions). When none of them names it, the fallback is the hash order: the draw
set sorted by SHA3-256(SHA3-256(seed) ‖ node key) descending, the blocksmith's index there. A block
whose blocksmith is at position ≥ 10 must be empty (no transactions; receipts allowed). The blocksmith
decides to build an empty block from the index of the first draw among rounds {r − 1, r} of its
block's round r that names it, and the candidate pool applies the rule to its priority (count − 1
of §6); both are local choices, and the validator's position is the one that makes a block valid.
How to compute it. As stated.
Rule activation. None.
Rejections and errors. 19 §2 step 6.
Vector. computed. INPUT: the draws of §1's seed-S vector, a block by 6b9aa5c7… at round 1.
EXPECTED: position 0, transactions allowed. INPUT: 10 selectable nodes, a blocksmith first drawn at round 11.
EXPECTED: position 10; its block must be empty, else "Blocksmith at position 10 is beyond max_priority_blocksmiths (10) and must produce empty blocks, but block contains 1 transactions"
(for one transaction). INPUT: 10 selectable nodes, a blocksmith drawn at rounds 1 and 11 (not 10)
whose block, stamped in round 11, carries one transaction. EXPECTED: validator position 0 (its
first draw is round 1), the block is valid; the blocksmith's own rule (rounds 10 and 11) gives 10.
Test cases · §3
5 cases · 3 valid · 2 invalid
A block by draw 1 over seed S at round 1: position 0, transactions allowed
Loading the test widget…
Ten nodes, a blocksmith first drawn at round 11 and carrying one transaction
Loading the test widget…
The same blocksmith with an empty block
Loading the test widget…
A blocksmith drawn at rounds 1 and 11 produces at round 11 with a transaction
Loading the test widget…
A blocksmith not drawn in the rounds of its timestamp
Loading the test widget…
Defects to match. With fewer than 10 selectable nodes the empty-block rule can only bite a blocksmith that waited through more than 10 rounds.
4. Producing a block
Purpose. What an implementation that produces does when it is drawn.
Inputs. Its node key pair; the previous block P; the draw set; the clock; the mempool; its
running bundle id (29); max_block_size_bytes; max_recovery_interval_seconds (3,600 when
absent).
Output and effect. Once now ≥ P.timestamp + 15 the node computes current_round from the clock
(§2); for each round from max(1, current_round − 1) to current_round, the earliest one whose draw
names this node and whose persist window has not ended is chosen; none → not a blocksmith now. It
does not produce before the genesis time ("Not time to produce block yet: before the genesis time (<genesis timestamp>)"), nor when its bundle id is below a bundle active at the next height (the
halt line of 29: under rule readiness_registry_schedule a release registered above the node's
own bundle is tallied by the node itself from the registry floor, the registration height plus
5,760 blocks, and the headers of the signal window, so it stops producing at that bundle's
activation height exactly as a newer binary does; validation continues). A registered node whose
registry read fails for the draw produces nothing in that pass ("local fault: the registry draw could not be read; not producing this pass"). The candidate:
version= the blocksmith's bundle id: 601 for 0.6.1 (29§4b);timestamp= max(target of the chosen round, its creation window start), raised to P + 15 if lower; refused when ≥ the creation window's end;previous_block_hash;block_seedand the 80-byteblock_seed_proof= the VRF output and proof over SHA3-256(previous seed) (05§5);- the transactions of
04§10, unless the position is ≥ 10 or the node's health monitor forces an empty block (local): among them, of several pooled copies around one foreign carrier id only the oldest (by arrival time, then transaction id) is eligible and a carrier whose id the chain already holds as spent is skipped (ruleforeign_carrier_bound), an Ethereum carrier is eligible only when its nonce is the sender's account nonce (the next one waits for the next block), a Solana or Bitcoin carrier only while its binding holds at the candidate's height, and a transaction of the survival frozen set is held in the pool while the candidate's survival flag is true (19§10); the receipts of23§6; total_coinbase= the coinbase schedule of21(block 1: 0; an empty block carries it too),total_fee= Σ fee,total_amount0;- then the size trim (rule
block_size_serialized,19§8): with the payload hash given its final 32 bytes, transactions are dropped from the end until the serialized size ≤max_block_size_bytes; then the Merkle root (32 zero bytes when empty), the payload hash and length (05), the difficulty string (§6), the signature and the hash (05).
When the candidate carries transactions it is dry-run through the block application of 19 §4
(nothing commits): when a transaction fails deterministically, it is evicted from the pool and the
candidate rebuilt without it (totals, Merkle root, payload, difficulty, signature recomputed); at the
second failure the candidate is rebuilt empty; a failure that is not deterministic leaves the
candidate as built. Then the one block per parent guard, keyed on the parent hash, with two slots
per parent: the block signed within the recovery limit and the block signed past it (past
when stamp − parent.timestamp > max_recovery_interval_seconds; the side is decided by the new
block's own stamp, never by the wall clock). Nothing signed on the stamp's side → sign and remember
it on that side; else re-send that same block (same bytes). So a blocksmith signs at most one block
per parent within the limit and one fresh resume block past it (which with the earlier block
straddles the limit and is not charged as equivocation, 35 §5). The guard is kept across restarts
in a local table producer_signed_parent (parent hash 32 bytes primary key, height, a within flag
and a past flag, and for each side the signed block in its wire form and its position; not
consensus, never in a snapshot); after a restart the stored block is re-sent; when a slot is marked
but its block cannot be read back, the blocksmith refuses ("Already signed a block over this parent before a restart (gate-D2b: never a second one)"; the pre-check of the round loop answers
"Already signed a block over this parent (gate-D2: never a second one)"; both local texts). Entries more than 720 heights below the tip are forgotten. The
candidate enters the local pool with its position and is broadcast at the earliest broadcast
time: P + 15 for position 0; for position p ≥ 1, max(P + 15, end of the persist window of round p − 5). Node-local: the broadcast time is local policy (only the block's timestamp is consensus), and a
node whose clock lags sees fewer open rounds and may miss its own turn.
How to compute it. As stated.
Rule activation. The size trim is rule block_size_serialized, the carrier selection rule
foreign_carrier_bound, the survival hold rule survival_mode, the halt line
activation_readiness_gate and readiness_registry_schedule: all active from height 0 on every
chain. A proven double-sign counts as a miss (35, 36).
Rejections and errors. Local: "Not time to produce block yet", "Not selected as blocksmith for current round", "Missed turn window for candidate block", the guard's refusal, the
validator's texts.
Vector. computed. INPUT: P = 1,793,713,987, this node drawn first (position 0). EXPECTED:
timestamp 1,793,714,002 (P + 15), broadcast at P + 15. INPUT: drawn second (position 1). EXPECTED:
block timestamp P + 30 (round 2 target), broadcast at max(P + 15, P + 22 − 5) = P + 17. INPUT (the
guard): signed B1 over parent P at P + 15; drawn again over P at P + 30 → re-sends B1; drawn at P +
3,615 (past the limit) → signs B2; drawn at P + 3,700 → re-sends B2. INPUT: a candidate with 3
transactions whose second fails execution deterministically. EXPECTED: that transaction evicted, the
candidate re-signed with 2. INPUT: two pooled SendZBC carriers wrapping one signed Ethereum
transaction, arrived at 10:00:00 and 10:00:01. EXPECTED: only the first is eligible; the second is
left in the pool (it expires there).
Test cases · §4
9 cases · 9 valid · 1 reference
Drawn first: timestamp and broadcast
Loading the test widget…
Drawn second: timestamp and broadcast
Loading the test widget…
One block per parent within the recovery limit and one past it
Loading the test widget…
After a restart the parent's slot is marked but its block cannot be read back
Loading the test widget…
Two pooled SendZBC carriers wrapping one signed Ethereum transaction, arrived at 10:00:00 and 10:00:01
Loading the test widget…
A carrier of the next nonce waits for the next block
Loading the test widget…
A carrier whose id the chain already holds as spent is skipped
Loading the test widget…
The carrier of the account nonce, alone in the pool
Loading the test widget…
A candidate whose second transaction fails execution deterministically
A stated value: there is nothing to compute. A compatible node shows the same value.
- value
that transaction is evicted and the candidate re-signed with the other 2
Defects to match. None.
5. Skipped blocksmiths
Purpose. An implementation must record the nodes drawn before the blocksmith, because the score
road (36) and the rollback replay read them.
Inputs. The applied block, its previous block, the draw set at the previous height (§1), the
receipt lookback 40, max_priority_blocksmiths, LIVENESS_STALL_ROUNDS 10.
Data. skipped_blocksmith(blocksmith_public_key 32 bytes, pop_change signed 64-bit (always 0), block_height u32, blocksmith_index signed 32-bit), indexed by block_height; written when a block is
applied; on a pop-off to t every row with block_height above t is deleted; pruned below min(the
receipt horizon, tip − max_rollback_height) (13 §8).
Output and effect. For height ≥ 40, the blocksmith list: round = the round of the block's
stamp (§2); when round > 10 (rule miss_by_rounds: a resume after a stall) the list is the blocksmith
alone; else the first round draws over the draw set, the blocksmith's index = its last draw among
them (none → no list, nothing recorded); when the blocksmith is the previous blocksmith the effective
index is max(index, F − 1), and its own draws at indices below F − 1 are left out; the list is the
draws before the effective index, then the blocksmith. Every entry before the blocksmith gets a row
(pop_change 0, index from 0, in list order). The score is not charged here: each skipped node
becomes missing in the block's liveness step (36), which computes the same list. A failure to
compute the list, to read the registry the step draws over or to write the rows refuses the block.
How to compute it. As stated.
Rule activation. one_round_formula, miss_by_rounds: active from height 0 on every chain.
Rejections and errors. None of its own (a failure refuses the block, 19 §4).
Vector. computed. INPUT: the draws over seed S (§1: draw 1 → 6b9aa5c7…, draw 2 →
715ea8e2…), a block at height 12,400 by 6b9aa5c7… at round 1. EXPECTED: list = [6b9aa5c7…],
no row. INPUT: the same parent, a block at round 2 by
715ea8e2f51bbcb778a26e69d73bd1044fe3a43d76cb1cf6cbc3a9a661a2fbac. EXPECTED: one row
(6b9aa5c7ca7f11c32b3bc6e006571319a7521aaa472f3c422f52626e48c3833e, 0, 12,400, 0). INPUT: a block
by the previous blocksmith drawn at round 2 and stamped in round 10. EXPECTED: rows for the draws
1 … 9 other than its own, the blocksmith last.
Test cases · §5
3 cases · 3 valid
Block 12,400 by draw 1 at round 1: no skipped row
Loading the test widget…
A block at round 2 by draw 2: one skipped row
Loading the test widget…
The previous blocksmith, drawn at round 2, stamps in round 10
Loading the test widget…
Defects to match. A node drawn twice before the blocksmith gets two rows.
6. Difficulty and cumulative difficulty
Inputs. The previous block's seed and difficulty string; the draw set at the previous height
(|S| nodes, rule difficulty_draw_set); the registry size |A| at the previous height (rule
weight_by_draw_share); the block's timestamp and blocksmith; the divisor D =
cumulative_difficulty_divisor (1,000,000 in both genesis files; 1,000,000 when absent or not
positive).
Output and effect. count = the last index (1-based) of a draw naming the blocksmith among the
draws of round (§2) over the draw set; else the first draw among the first 2|S| naming it, plus 1;
else the hash-order position (§3) plus 1. Then two floors: count = max(count, F) (F = 10) when the
blocksmith is the demoted previous blocksmith, and count = max(count, round) always (rule
late_stamp_priced). increment = floor(D × min(|S|, |A|) / (count × |A|)) computed in 128 bits;
the block's string = decimal(previous + increment), unbounded. The candidate pool's priority is
count − 1.
How to compute it. As stated.
Rule activation. difficulty_draw_set, late_stamp_priced, weight_by_draw_share: active
from height 0 on every chain.
Rejections and errors. 19 §2 step 13.
Vector. computed. INPUT: the previous block's string 11810449964, a block by draw 1 at
round 1, |S| = |A| = 11. EXPECTED: count 1, increment floor(10⁶ × 11 / (1 × 11)) = 1,000,000,
string 11811449964. INPUT: |A| = 11, 2 suspended (|S| = 9), a round-1 block by draw 1. EXPECTED:
floor(10⁶ × 9 / 11) = 818,181. INPUT: the previous blocksmith's block at round 10, same sets.
EXPECTED: floor(10⁶ × 9 / (10 × 11)) = 81,818. INVALID: the first block carrying 11811449965.
EXPECTED: "Cumulative difficulty mismatch: expected 11811449964, got '11811449965'".
Test cases · §6
4 cases · 3 valid · 1 invalid
A block by draw 1 at round 1, |S| = |A| = 11: increment and cumulative difficulty
Loading the test widget…
The same block carrying 11811449965
Loading the test widget…
Two of eleven suspended (nine selectable), a round-1 block by draw 1
Loading the test widget…
The previous blocksmith's block at round 10, same sets
Loading the test widget…
Defects to match. None.
7. Who earns, and the production set
Purpose. An implementation must decide the same set of earning nodes for every payout (21,
13 §7, 22).
Inputs. The liveness rows and the unit clock as of the previous block (rule payout_instant);
maturity_units 4; the unit = max(n, score_unit_floor_blocks) (testnet 2,880, devnet 120; 36);
the roll call (§1).
Output and effect. A node earns at block h (one view for every payout: the coinbase lottery,
the longevity slice, the storage reward, the archive reward, the taker fee) when it is not missing
and not suspended at h − 1 and it is mature: a genesis registered node (registration height 0) at once; a
newcomer once it has produced a block and maturity_units units have passed on the unit clock
since its admission; in blocks 2 … roll_call_blocks, while the roll call restricts the draw, a
genesis registered node that has not answered earns nothing. A failed read of the rows, the clock or the answers
refuses the block. The production set of §1 does not depend on earning.
How to compute it. As stated (36 defines the clock and the missing state).
Rule activation. payout_instant: active from height 0 on every chain.
Rejections and errors. None.
Vector. computed. INPUT (unit 2,880, the testnet genesis file's floor): a newcomer admitted at height h, first own block at h + 100.
EXPECTED: earns from the first block after both 4 units (4 × 10¹² ticks) on the unit clock (36)
since its admission and its first own block (h + 100); at 347,222,222 ticks per block the 4 units
take 11,521 blocks (11,520 blocks give 3,999,999,997,440 ticks). INPUT: a
genesis registered node, not missing, not suspended. EXPECTED: earns at once.
Test cases · §7
3 cases · 3 valid
A newcomer on the testnet unit clock: blocks until mature
Loading the test widget…
A genesis registered node earns at once
Loading the test widget…
A newcomer that has produced no block is not mature
Loading the test widget…
Defects to match. None.
8. The consensus/local split
Consensus: the generator, the two sets and their order (the roll call and the demotion included),
the round and window arithmetic, the position and empty-block rule, the block timestamp, version
and coinbase a blocksmith must use, the size bound of its candidate, the skipped list, the difficulty
string over the draw set with its floors and share, who earns. Local: the one-block-per-parent guard
and its table, the dry run, when a node starts producing, the broadcast delay, the health-monitor
empty block, the candidate pool's clock-driven selection (19 §5).
A question about this chapter, or a statement that does not match the network? Discuss on zoobc.pro.