On this page
- §0 The area in one paragraph
- 1. The schedule
- 2. Escrow expiry (S1)
- 3. Liquid-payment completion (S2)
- 4. Due solo bets, channel settlements, unstarted apps and order expiry (S3–S5)
- 5. The fee-scale count (P1)
- 6. Dataset rent (P2)
- 7. Token expiry settlement (P3)
- 8. Account rent and account pruning (P4)
- 9. Height triggers (P5) and timed schedules (P6)
- 10. Gateway pruning (P7)
- 11. Stored-file rent (P8), the storage-proof tally (P11) and the archive reward (A)
- 12. Longevity rent (P9) and the longevity payout (P10)
- 13. Oracle resolution (P12), bridge deposits and withdrawals (P13–P14), the price count (P15), release governance (P15b)
- 14. The prune (P16) and the snapshot trigger
- 15. Ledger rows and the consensus/local split
22 — Periodic processors
Out of scope the steps of block application that 19 §4 and 21 order (transactions, receipts, scores, the reward lottery, the registry step, liveness); the transaction types that create what these processors act on (08, 10–18); the full schema of every table (07); the inner rules the cross-referenced sections already specify in full (restated here only as far as the processor's own inputs, order and outputs go); the survival flag itself (19 §10)
§0 The area in one paragraph
Besides its transactions, every block runs a fixed list of processors in a fixed order, and an
implementation must run exactly the same list in the same order, because each one changes balances
and rows that the next one reads: six sweeps before the transactions (escrows past their
timeout, liquid payments past their end, solo bets due to resolve, channel settlements past their
deadline, multiplayer apps nobody started, orders past their expiry; the timestamp sweeps read the
previous block's stamp), the archive's epoch reward before the block is stored, and the steps after
the registry and liveness steps: the fee-scale count, dataset rent, token expiry, account rent,
height triggers, timed schedules, gateway pruning, stored-file rent, market rent, longevity rent,
the storage-proof tally, oracle resolution, bridge deposits and withdrawals, the price count,
release governance, and the prune. Every rent is billed per snapshot cycle
(main_snapshot_interval blocks) and goes to the longevity pool (file rent to the storage pool);
the fee scale and the governable prices move once per cycle, at its last block, by the capped
average of 17 — except when that block is judged in survival mode (19 §10): then the count
is skipped and the cycle's votes lapse, and the oracle, bridge and release-governance resolutions
wait for the first block out of survival mode, their windows not counting the survival heights.
Each processor selects its due rows by a stated condition
and order, acts on each in that order with integer arithmetic, writes versioned rows at the block's
height and ledger rows with transaction_id 0 (or the row's own id) and the block's timestamp. A
row the rules refuse is skipped, and an implementation must reproduce the skips; but a processor
that cannot read what it decides on (the due escrows and liquid payments, the counted registered
nodes, the events, the votes, who earns, a parameter, an account, the archive's sample, the survival
flag) makes the block refused on that
node (19 §4): a failed read is never taken for "nothing there".
1. The schedule
Purpose. Which processors an implementation runs, when, in what order, on what inputs.
Inputs. The block (height h, timestamp, seed, blocksmith key, transactions); the previous
block (its timestamp is the expiry clock of the sweeps marked "previous stamp", rule
expiry_previous_stamp); the state; the chain parameters named per step, each read from
consensus_parameters at the time the step runs (the compiled constant when the row is absent);
the cycle length L = main_snapshot_interval (testnet 172,800 / devnet 240; absent or ≤ 0 →
172,800; never below 2); the survival flag of h (19 §10).
Output and effect. Inside the block's single database transaction (19 §4), in this order:
| # | Processor | Runs when | Selection order | Writes (ledger events) | Full rule |
|---|---|---|---|---|---|
| S1 | Escrow expiry | every block, previous stamp | stored order | event 9, escrow status 3 | §2, 12 §5 |
| S2 | Liquid-payment completion | every block, previous stamp | stored order | event 14, status 1 | §3 |
| S3 | Due solo bets | h > 0 | ascending app id | event 100, app Finished | §4, 16 §6 |
| S4 | Due channel settlements | h > 0 | stored order | app settlements | §4, 16 §8 |
| S4b | Unstarted multiplayer apps close | h > 0 | ascending app id | events 100 and 84, app Cancelled | 16 §3a |
| S5 | Order expiry | h > 0, previous stamp | ascending order id | event 59, order Expired | §4, 15 §8 |
| — | the transactions, the receipts, the skipped rows, A: the archive's epoch reward (before the block is stored; before the lottery slices the pool), the store and the lottery (21 §2), the survival flag of h written (19 §10), the registry step, the liveness step, the leave step (21 §1, §4) |
||||
| P1 | Fee-scale count | seeded on first use; counted at the cycle's last block (h mod L = 0) unless the flag of h is true | each registered node's latest reveal of the cycle | fee_scale row |
§5, 17 §3 |
| P2 | Dataset rent | every block | one due row per object, objects in byte order of (object, setter, recipient, property) | events 17/18/19→pool/32/50/83 | §6, 10 §12 |
| P3 | Token expiry | every block | ascending token id | events 20/21 | §7, 13 §10 |
| P4 | Account rent | every block, at most 2,000 rows | (rent_due_height, account_address) |
events 24/25/83; 19 or 50 on the pool | §8, 13 §9 |
| P5 | Height triggers | every block | ascending trigger id | event 23 | §9 |
| P6 | Timed schedules | every block, previous stamp | ascending trigger id | events 28/29/30/34 | §9, 08 §6 |
| P7 | Gateway pruning | every block | ascending row height | event 31 | §10, 17 §7 |
| P8 | Stored-file rent | every block | ascending file root | events 69/50 | §11, 11 §4 |
| P8b | Market rent | every block | ascending market id | events 19/59, market Pruned | 15 §8 |
| P9 | Longevity rent | every block | ascending target id | event 38 (and 50) | §12, 13 §6 |
| P10 | Longevity payout | does nothing (rule longevity_continuous): the pool pays a per-block slice in the block's lottery (event 39, 21 §2) |
— | — | §12 |
| P11 | Storage-proof tally | h mod E = 0 and h ≥ 2E (E = storage_proof_epoch_blocks) |
pieces in stored order, the archive's sampled chunks left to A | event 19 | §11, 11 §7 |
| P12 | Oracle resolution | every block unless the flag of h is true | unresolved event ids in stored order | event 23 | §13, 17 §4 |
| P13 | Bridge deposits | every block unless the flag of h is true | ids in stored order | mint | §13, 34 |
| P14 | Bridge withdrawals | every block unless the flag of h is true | ids in stored order | burn | §13, 34 |
| P15 | Price count | the cycle's last block unless the flag of h is true | each registered node's latest vote per price | consensus_parameters + consensus_parameter_change |
§13, 17 §5 |
| P15b | Release governance | every block unless the flag of h is true | ZBCREL1: ids with a vote whose survival-adjusted age is within 172,800 blocks |
release revoked / authority replaced | §13, 17 §6 |
| — | the step-fault check (the fault record is cleared before S1; a failed read noted by S1, S2, A, P1, P2's pool credit, P8 or P11–P15b refuses the block here), the rule edge records, the parameter-read check, the readiness gate and its decision row (21 §1 step 13) |
||||
| P16 | Prune | every block (unless the node keeps everything) | — | deletes | §14, 13 §8 |
Before the transactions run, the executor is told the block's blocksmith account (the owner
account of the node_registry row holding the blocksmith key, the newest version at or below the
block's height; a failed read refuses the block) and whether the blocksmith earns at the block
(20 §7; the taker fee's recipient, 15 §6), the block's seed and timestamp; 08, 15,
16 and the schedules read them.
Versioned rows. Every table written here that 07 marks versioned keeps one row per key per
height: a write at height h inserts the row with latest = 1 at h and clears latest on the key's
previous newest row; a pop to height t deletes every row above t and gives latest back to the
newest row of each key at or below t (07 §2, 24). "The current row" below always means the row
with latest = 1. Ledger rows (account_ledger: account, balance change, block height,
transaction id, timestamp, event type) are history rows, deleted above t on a pop.
How to compute it. Run the list in the order above; nothing else is interleaved.
Rule activation. Per step. The two survival skips (P1, P15) and the four survival pauses
(P12–P14, P15b) are rule survival_mode (19 §10), active from height 0 on every chain.
Rejections and errors. A row the rules refuse is skipped; a failed read in a step refuses the
block on this node ("A block step's read failed at height H: … (block refused)"); a storage fault
refuses it (19 §4).
Vector. computed (testnet: L = 172,800, E = 240):
| Input: height | P1/P15 count? | P11 runs? | P11's closed epoch | P11's seed block |
|---|---|---|---|---|
| 480 | no (480 mod 172,800 ≠ 0) | yes (480 mod 240 = 0, 480 ≥ 480) | 1 | 240 |
| 12,480 | no | yes | 51 | 12,240 |
| 172,800 | yes (flag false) / skipped (flag true) | yes | 719 | 172,560 |
| 240 | no | no (240 < 2 × 240) | — | — |
Test cases · §1
6 cases · 6 valid · 1 reference
Height 480 on the testnet
Loading the test widget…
Height 12,480 on the testnet
Loading the test widget…
Height 172,800: the cycle's last block
Loading the test widget…
Height 172,800 judged in survival mode
Loading the test widget…
Height 240: P11 waits for two epochs
Loading the test widget…
The addresses exempt from account rent
A stated value: there is nothing to compute. A compatible node shows the same value.
- longevity_pool
000000005a42434c4f4e4756000000000000000000000000000000000000000000000000- storage_pool
000000005a424353544f5245000000000000000000000000000000000000000000000000- carry
000000005a42434341525259000000000000000000000000000000000000000000000000- apps_pool
000000005a42434150505300000000000000000000000000000000000000000000000000- datasets
every ZBS_ address (account type 10)
Defects to match. The three system pools (00000000‖"ZBCLONGV", "ZBCSTORE", "ZBCCARRY", each
padded with zero bytes to 36), the apps pool (00000000‖"ZBCAPPS" padded to 36) and every dataset
(ZBS_, account type 10) address are exempt from account rent (§8) but from nothing else; every
other deposit address pays account rent like any account.
2. Escrow expiry (S1)
Purpose. An implementation returns what a pending escrow holds once its timeout has passed, or once the pruning horizon would strand it.
Inputs. The block's height and the expiry clock (the previous block's timestamp); the current
escrow_transaction rows with status = 0 (columns used: id i64, sender_address, amount
i64, commission i64, timeout i64 Unix seconds, token_id i64, block_height); the pruning
horizon of h, horizon(h) of 12 §5 (0 = none; the same number on every node); the current
longevity rows.
Output and effect. Due rows: timeout < clock, or (horizon(h) > 0) the escrow row's own
block_height is below horizon(h) and no current longevity record with deposit > 0 targets
its id (rule escrow_horizon_pure: never whether this node still holds the transaction row).
For each, in stored order: a ZBC escrow refunds amount + commission; a token escrow
(token_id ≠ 0) returns amount token units to the sender (a plain token credit, no ledger row)
and refunds only commission in ZBC; the ZBC refund is a plain credit to the sender's balance
holder (18) with a ledger row event 9, transaction_id = the escrow id, the block's timestamp;
then the escrow gets a new version with status 3 (Expired), block_height = h, the other fields
kept. A refund that fails leaves the row pending (retried next block).
How to compute it. As stated; < is strict; the horizon clause has no timeout condition.
Rule activation. balance_credit_full_row, expiry_previous_stamp, escrow_horizon_pure:
active from height 0 on every chain.
Rejections and errors. A read of the due escrow list that fails is a step fault: the block is
refused on this node ("A block step's read failed at height H: … (block refused)", §1), never
applied with the sweep skipped. A refund that fails leaves the row pending (above).
Vector. computed. INPUT: escrow id 7, sender 00000000‖11×32, amount 100,000,000, commission
1,000,000, token_id 0, timeout 1,793,700,000, status 0; block h = 12,000 whose previous block is
stamped 1,793,700,001 (the block itself 1,793,700,016). EXPECTED OUTPUT: sender balance +101,000,000;
ledger row (sender, +101,000,000, 12,000, transaction id 7, timestamp 1,793,700,016, event 9);
escrow 7 version at 12,000 with status 3. The same escrow with the previous block stamped exactly
1,793,700,000 → nothing (1,793,700,000 < 1,793,700,000 is false).
Test cases · §2
7 cases · 7 valid
Escrow 7, the previous block stamped one second past its timeout
Loading the test widget…
Escrow 7's ledger row and new version
Loading the test widget…
The previous block stamped exactly at the timeout
Loading the test widget…
A token escrow returns its units and refunds only the commission
Loading the test widget…
An escrow of height 12,500 at block 345,600: below the horizon, expired whatever its timeout
Loading the test widget…
The same escrow at block 345,599: no horizon yet
Loading the test widget…
The same escrow with a funded longevity record: kept
Loading the test widget…
Defects to match. 12 §5.
3. Liquid-payment completion (S2)
Purpose. An implementation pays out a stream that has run its full course.
Inputs. Current liquid_payment_transaction rows with status = 0 and applied_time + complete_minutes × 60 ≤ clock (clock = the previous block's timestamp); columns used: id,
sender_address, recipient_address, amount, applied_time, complete_minutes, token_id;
the block's height and timestamp.
Output and effect. For each due row in stored order: elapsed = clock − applied_time
(negative → skipped and retried); because the row is due only when elapsed ≥ complete_minutes × 60, the recipient receives the whole amount and the sender nothing (the partial split exists
only in LiquidPaymentStop, 08 §4). ZBC (token_id 0): the recipient is credited as an incoming
payment (its split policy applies, 08 §10), ledger row event 14 on the recipient with
transaction_id = the payment id and the block's timestamp. Token: the units are credited to the
recipient as an incoming token payment, no ledger row. Then a new version of the row with status 1
(Completed), block_height = h.
How to compute it. recipient_share = amount; sender_share = 0. (A pro-rata rate computed in floating
point gives the same for every due row.)
Rule activation. balance_credit_full_row, expiry_previous_stamp (height 0 everywhere).
Rejections and errors. A failed credit leaves the row pending. A read of the due list that fails is a step fault: the block is refused on this node (§1), never applied with the payments skipped.
Vector. computed. INPUT: stream id 9, amount 100,000,000 ZBC, complete_minutes 10,
applied_time 1,792,000,000; block h whose previous block is stamped 1,792,000,600. EXPECTED
OUTPUT: recipient +100,000,000 (ledger event 14, transaction id 9), row status 1 at h. With the
previous block stamped 1,792,000,599 → not due, nothing written.
Test cases · §3
2 cases · 2 valid
Stream 9 after its ten minutes
Loading the test widget…
One second early
Loading the test widget…
Defects to match. complete_minutes = 0 cannot exist (08 §4 refuses it); were it present the
whole amount would be paid at once.
4. Due solo bets, channel settlements, unstarted apps and order expiry (S3–S5)
Purpose. An implementation closes app, settlement and order rows by height or timestamp.
Inputs. S3: current app rows that are active solo apps with 0 < resolve_height ≤ h, the
block's seed, the apps pool balance, the per-token payout cap (16 §6); S4: current
app_settlement rows not resolved with deadline < h; S4b: unstarted multiplayer apps past their
join window (16 §3a); S5: current order_book rows that are Open with expiry ≠ 0 and expiry ≤
the previous block's timestamp.
Output and effect. S3 (ascending app id, 16 §6 in full): r = the app's tagged random draw
from the seed, the type's payout rule, a win pays min(payout, pool balance, cap left) from the
pool to the player in place 0 (rows event 100: −pay on the pool, +pay on the player, transaction_id =
the app id), the rest owed on the row (owed_payout) and paid from later blocks' caps in app-id
order; every payment adds to the row's paid_payout. The cap of a token, read once per block before
any payment in that token, is the solo stakes bet in the last 5,760 blocks
(APPS_PAYOUT_INFLOW_WINDOW_BLOCKS) minus the solo wins paid in that window (rule
apps_payout_cap_net), never below 0; an empty cap holds back only its own token's wins. Win or
lose the app becomes Finished with last_move_height = h. S4 (stored order): a settlement whose
app is still Active with channel = 1 is settled from the recorded state (16 §8) and the app
becomes Finished; the settlement row is marked resolved whether or not its app still existed. S5
(ascending order id): an order still Open releases its remaining hold (base for a sell, quote = floor(remaining × price / 10⁸) for a buy; row event 59, transaction_id = the order id) and becomes
Expired at h; an order whose market is unknown is left resting.
Rule activation. apps_payout_cap, apps_payout_cap_net and the others of 15/16: active
from height 0 on every chain.
Rejections and errors. None.
Vector. computed (S5). INPUT: buy order id 41, remaining 300,000,000 base units, price
150,000,000 (1.5 quote per base), expiry 1,793,700,000, Open; the previous block stamped
1,793,700,000. EXPECTED OUTPUT: the maker's quote hold released, quote = floor(300,000,000 ×
150,000,000 / 10⁸) = 450,000,000 units (ledger event 59, transaction id 41); order 41 Expired at h.
With expiry 0 → never expired by this sweep. computed (S3 cap): token 0, stakes bet in the window
2,000,000,000, solo wins paid in the window 1,500,000,000 → the block's cap is 500,000,000; a win of
800,000,000 pays 500,000,000 and owes 300,000,000.
Test cases · §4
3 cases · 3 valid
Buy order 41 expires and releases its quote hold
Loading the test widget…
An order with expiry 0 never expires here
Loading the test widget…
The solo payout cap of token 0 and a win of 800,000,000
Loading the test widget…
5. The fee-scale count (P1)
Purpose. An implementation moves the transfer-fee scale once per snapshot cycle from the revealed votes, unless the counting block is in survival mode.
Inputs. The current fee_scale row (columns fee_scale i64, block_height, latest); the
cycle length L; the cycle's reveals (fee_vote_reveal_vote, each registered node's latest reveal of blocks
[first block of the cycle, h]); the counted registered nodes at the previous block (17 §1); the registry
floor max(3, min_registry_size); the survival flag of h (19 §10).
Output and effect. Exactly 17 §3: the row is seeded (fee_scale 1,000,000, block_height 0,
latest 1) by the first block that finds none (a failed read or write refuses the block). At the
cycle's last block (h > 0 and h mod L = 0): when the survival flag of h is true the count is
skipped — no row is written, the scale stays, and the cycle's commitments and reveals lapse (the
next cycle starts after h); a flag that cannot be read is a step fault (the block is refused).
Otherwise the scale becomes the capped average of each registered node's latest reveal of the cycle over the
counted registered nodes (today's value when they fail the registry floor), bounds 1 … 100,000,000, and a
new row (new value, h, 1) is written whether or not it changed.
How to compute it. The capped average (17 §3): t = today's value held to [lo, hi]; each vote
is held to [max(lo, t div 2 + t mod 2), min(hi, t + max(1, t div 5))]; n = max(counted registered nodes, votes);
sum = Σ held votes + (n − votes) × t in 128-bit; new = (sum + n div 2) div n, held to [lo, hi];
n = 0 → t.
Rule activation. The skip is rule survival_mode, active from height 0 on every chain.
Rejections and errors. A failed read refuses the block.
Vector. computed. INPUT: today 1,000,000, lo 1, hi 100,000,000, 7 counted registered nodes, reveals
2,000,000 / 900,000 / 1,100,000 (four of them silent), h = 172,800 on a chain with L = 172,800, flag
of h false. EXPECTED OUTPUT: held votes 1,200,000 / 900,000 / 1,100,000; sum = 3,200,000 + 4 ×
1,000,000 = 7,200,000; new = (7,200,000 + 3) div 7 = 1,028,571; row (1,028,571, 172,800, 1).
The same input with the flag of h true → no row; the scale stays 1,000,000; the three reveals are
never counted. The same at h = 172,799 → nothing (not the cycle's last block).
Test cases · §5
3 cases · 3 valid
The fee-scale count at 172,800
Loading the test widget…
The same count at 172,800 in survival mode is skipped
Loading the test widget…
Height 172,799 is not the cycle's last block
Loading the test widget…
Defects to match. 17 §3.
6. Dataset rent (P2)
Purpose. An implementation charges every active dataset object its rent once per period.
Inputs. dataset_storage_cost_per_mib (testnet 5,000,000 / devnet 100,000,000),
storage_oracle_multiplier_ppm (1,000,000), both read fresh at the step, the period = the
snapshot cycle L; the current active account_dataset rows that carry a creating_tx_hash; the
current dataset_object row of each object (its rent clock last_billing_height, its
owner_account); the confirmed balances of the object's deposit address 0A000000‖object_id
(36 bytes) and of the owner, and the owner's prepaid_storage_balance (never this node's pool
reservations).
Output and effect. Exactly 10 §12 (rule dataset_rent_object_clock). The object of a row is
its object_id, else (a row without one) its creating_tx_hash. Each object has one rent clock
C: its dataset_object row's last_billing_height when above 0, else the lowest
last_billing_height among its active rows. The due set is one row per object with
h − C ≥ period: the object's first active row in byte order of (object, setter, recipient,
property), the objects taken in that same order. A due object is re-clocked (its object row, or a
billing-only object row, and every active row of the object get a new version at h with
last_billing_height = h, 10 §12). fee = the storage fee (below) of Σ (property bytes + value bytes) over
the object's active rows (the due row alone when the object has none). Then: deposit ≥ fee → the
deposit pays (ledger event 17, −fee, on the deposit address); else, when the owner's prepaid storage
and balance together cover fee − deposit, the whole deposit plus the shortfall from the owner, its
prepaid storage first (rows on the owner: event 83 +what the prepaid storage paid, event 17 −the
shortfall); else every active row of the object is deactivated, the deposit (if > 0) is swept to
the longevity pool (event 50 on both sides, rule survival_field), and a row event 18 (0) is
written on the deposit address. A part is collected only when its debit happened. After the loop
the block's collected total is credited to the longevity pool 00000000‖"ZBCLONGV" (one row
event 19, transaction_id 0); a credit that fails refuses the block. The owner is the object's
owner_account, else (a legacy row without an object record) the row's setter.
How to compute it. The storage fee of bytes at rate and ppm = 0 when bytes, rate or
ppm ≤ 0; else ceil(ceil(bytes × rate / 1,048,576) × ppm / 1,000,000), exact in 128-bit,
saturating at 2⁶³ − 1.
Rule activation. dataset_rent_object_clock and survival_field: active from height 0 on every chain.
Rejections and errors. None of its own; a refused debit collects nothing; a failed pool credit
refuses the block, and so does a failed read of the due set, of an object's rows or of its object
row (the apply's read check, 21 §1 step 13).
Vector. computed. INPUT → EXPECTED OUTPUT (ppm 1,000,000): 218 bytes at 100,000,000 → 20,791;
218 bytes at 5,000,000 → 1,040; 9 bytes at 5,000,000 → 43; 1,048,576 bytes at 5,000,000 →
5,000,000; 0 bytes → 0. INPUT: object of 218 bytes (testnet rate), deposit 1,000, owner prepaid 0
and balance 10,000. EXPECTED OUTPUT: deposit −1,000 (event 17), owner −40 (event 17), pool +1,040
(event 19). With owner balance 30 → the object is pruned: its rows deactivated, the 1,000 swept to
the pool (event 50), event 18 (0) on the deposit, nothing collected.
Test cases · §6
5 cases · 5 valid
The storage fee of 218 bytes at the devnet rate
Loading the test widget…
The storage fee at the testnet rate
Loading the test widget…
An object of 218 bytes with a deposit of 1,000
Loading the test widget…
The same with an owner balance of 30
Loading the test widget…
Two records of one object, written at 100 and 200: one charge, both re-clocked
Loading the test widget…
Defects to match. 10 §12.
7. Token expiry settlement (P3)
Purpose. An implementation returns a dead token's backing.
Inputs. Current token rows with 0 < persist_height < h and backing_amount > 0, ascending
token_id; the holdings at the block's timestamp (13 §10: balances, open orders' remaining or
quote, open offers' give, pending token escrows (sender), pre-locked schedules (owner), pending
streams (ceil-vested to the recipient, rest to the sender), seated multiplayer stakes).
Output and effect. Exactly 13 §10 (rule token_expiry_to_holders): a ZBC-backed token
(backing_asset = 0) splits its backing pro rata over the holders, each share a plain credit with
ledger event 21 (transaction_id = the token id); with no holder the issuer receives the whole
backing (event 21). Then a token version with backing_amount 0 and a row event 20 (0) on the
issuer. Tokens backed by another asset or holding no backing are never settled, only hidden.
How to compute it. The split of total over holders with units > 0 (sum U): each share =
floor(total × units / U) in 128-bit; the leftover (fewer units than holders) goes one unit each to
the largest remainders total × units mod U, ties by the holder address bytes ascending.
Rule activation. token_expiry_to_holders and failed_credit_to_pool (the refused-credit
fallback below): active from height 0 on every chain.
Rejections and errors. A holder credit refused for a deterministic reason (the balance would
overflow, or the holder address fails the typed-address check) is paid to the longevity pool
instead (rule failed_credit_to_pool: a plain credit of that share to 00000000‖"ZBCLONGV" with
a ledger row event 50, transaction_id = the token id, the block's timestamp; the holder gets no
row); a pool credit that fails is a step fault (the block is refused); a storage fault refuses the
block on this node.
Vector. computed. INPUT: total 100; holders 00000000‖22×32 1 unit, 00000000‖11×32 1 unit,
00000000‖33×32 1 unit. EXPECTED OUTPUT: 33 / 34 / 33 (all remainders 1; the leftover goes to
00000000‖11×32, the lowest bytes). INPUT: total 10 over 1 / 2 / 3 units (holders …11, …22, …33).
EXPECTED OUTPUT: 2 / 3 / 5 (floors 1 / 3 / 5, remainders 4 / 2 / 0). INPUT: total 1,000 over 3 / 7
→ 300 / 700.
Test cases · §7
3 cases · 3 valid
100 over three holders of one unit each
Loading the test widget…
10 over 1, 2 and 3 units
Loading the test widget…
1,000 over 3 and 7 units
Loading the test widget…
Defects to match. 13 §10.
8. Account rent and account pruning (P4)
Purpose. An implementation charges the periodic reserve every funded address pays, and tombstones the address that cannot pay.
Inputs. account_rent_period_cost (testnet 1,000,000 / devnet 100,000,000), the period = the
snapshot cycle L; the current account_balance rows with 0 < rent_due_height ≤ h, ordered by
(rent_due_height, account_address) ascending, the first 2,000 (ACCOUNT_RENT_MAX_PER_BLOCK) taken
before the exempt addresses (§1 Defects) and group members (an address whose balance holder is
its group, 18) are dropped from them; for each, its row (balance, spendable_balance,
prepaid_storage_balance, rent_due_height).
Output and effect. Exactly 13 §9: cost = base for an address, base + storage fee(group weight, cost_per_mib, ppm) for a group address (18 §9). The rent is covered when prepaid ≥ cost or balance ≥ cost − prepaid (prepaid held at ≥ 0). Covered: the prepaid storage pays
min(prepaid, cost) and the balance the rest (spendable_balance reduced by the same, never below
0); rent_due_height advances by whole periods until it is above h; ledger rows on the account:
event 83 +what the prepaid paid (when > 0), event 24 −cost; the longevity pool +cost (event 19).
Not covered: the tombstone — a new row with balance, spendable balance, pop revenue, nonce and
rent_due_height 0 (the split policy cleared, an active group dissolved); rows event 83 +prepaid
(when > 0) and event 25 −(balance + prepaid); balance + prepaid credited to the pool (event 50).
Rows over the 2,000 wait for the next block. In the block at the height of rule genesis_rent_clock,
before the sweep, every current row with rent_due_height 0, a balance above 0, stored in its
canonical form, not exempt and not a member is armed with rent_due_height = h + L; on a chain with
the rule at 0 the genesis builder arms the genesis rows instead (06), and this never runs.
How to compute it. As stated.
Rule activation. genesis_rent_clock, active from height 0 on every chain.
Rejections and errors. A failed charge leaves the row for the next block; a due list that cannot be read refuses the block.
Vector. computed (testnet: cost 1,000,000, L 172,800). INPUT: account 00000000‖44×32,
balance 5,000,000, prepaid 300,000, rent_due_height 172,900; h = 172,900. EXPECTED OUTPUT: prepaid
0, balance 4,300,000, rent_due_height 345,700; ledger: event 83 +300,000, event 24 −1,000,000;
pool +1,000,000 (event 19). INPUT: balance 400,000, prepaid 100,000, same due. EXPECTED OUTPUT: not
covered (100,000 < 1,000,000 and 400,000 < 900,000) → tombstone; ledger: event 83 +100,000, event 25
−500,000; pool +500,000 (event 50). A group address of weight 284 bytes pays 1,000,000 +
ceil(284 × 5,000,000 / 1,048,576) = 1,001,355 per cycle.
Test cases · §8
3 cases · 3 valid
Account rent paid from prepaid storage first
Loading the test widget…
Account rent not covered: the account is tombstoned
Loading the test widget…
The rent of a group address of weight 284 bytes
Loading the test widget…
Defects to match. 13 §9; the 2,000 cap defers rent deterministically (every node takes the
same first 2,000 rows, exempt and member rows included, before dropping those).
9. Height triggers (P5) and timed schedules (P6)
Purpose. An implementation pays out pre-funded triggers at a height and runs recurring transfers at a time.
Inputs. P5: current trigger_schedule rows with status = 0, kind = 0, empty event_id,
fire_height ≤ h, ascending trigger_id. P6: current rows with status = 0 and 0 < fire_time ≤
the previous block's timestamp, ascending trigger_id; the rules of 08 §6.
Output and effect. P5: each trigger's amount (locked at creation, 08 §5) is credited to its
recipient as an incoming payment from the trigger's owner (split policy applies), ledger row event
23 with transaction_id = the trigger id; a credit refused for a deterministic reason (the balance
would overflow, or the recipient address fails the typed-address check) is paid to the longevity
pool instead (rule failed_credit_to_pool: ledger row event 50 on the pool, transaction_id = the
trigger id; a pool credit that fails is a step fault); the row's status becomes 1 (fired) either
way; a storage fault refuses the block on this node. P6: exactly 08 §6 "Firing": pre-locked
(mode 0) tranches from the locked remainder (events 29, or 28 for a vesting row, the last tranche
carrying the remainder; the leftover returned at the end, event 34, rule schedule_end_refund; a
leftover whose return to the owner is refused for a deterministic reason goes to the longevity pool
instead, event 50 for ZBC and the pool's token balance for a token schedule, rule
failed_credit_to_pool); pull-mode fires move per_fire_amount from the owner when affordable and
allowed by the member gate (rule schedule_fire_member_gate), rows event 29 on both sides, else a
row event 30 (0) and a skip counter that cancels the schedule (status 2) at 4 consecutive skips
(SCHEDULE_MAX_CONSECUTIVE_SKIPS); re-arm fire_time += interval_seconds unless the fires are
exhausted, the end time is passed or the addition overflows (status 1). Token schedules move token
units without ledger rows.
How to compute it. 08 §6.
Rule activation. schedule_end_refund, schedule_fire_member_gate, expiry_previous_stamp,
failed_credit_to_pool: active from height 0 on every chain.
Rejections and errors. None.
Vector. computed. INPUT: trigger 12, kind 0, amount 50,000,000, recipient 00000000‖55×32,
fire_height 1,000, status 0; h = 1,000. EXPECTED OUTPUT: recipient +50,000,000 (event 23,
transaction id 12), trigger 12 status 1 at 1,000. At h = 999 → nothing. INPUT: the same trigger
whose recipient's balance would overflow. EXPECTED OUTPUT: the longevity pool +50,000,000 (event
50, transaction id 12), the recipient unchanged, trigger 12 status 1. 08 §5–§6 hold the schedule
vectors.
Test cases · §9
3 cases · 3 valid
Trigger 12 at height 1,000
Loading the test widget…
Trigger 12 at height 999
Loading the test widget…
Trigger 12 whose recipient's balance would overflow: paid to the longevity pool
Loading the test widget…
Defects to match. 08 §6.
10. Gateway pruning (P7)
Purpose. An implementation expels a gateway that stopped beating and returns its stake.
Inputs. gateway_heartbeat_interval (240 in both genesis files; compiled 5,760) and
gateway_prune_grace (480; compiled 11,520); current gateway_registry rows with status = 0,
block_height > 0 and last_heartbeat_height < h − (interval + grace) (no row when h ≤ interval +
grace), ascending row height.
Output and effect. For each: locked_stake > 0 with a known owner → a plain credit of the stake
to the owner, row event 31 (transaction_id 0); a credit refused for a deterministic reason (the
balance would overflow, or the owner address fails the typed-address check) is paid to the
longevity pool instead (rule failed_credit_to_pool: row event 50 on the pool, transaction_id
0); then a gateway version with status 1 (pruned) at h.
How to compute it. As stated.
Rule activation. failed_credit_to_pool, active from height 0 on every chain.
Rejections and errors. None of its own; a pool credit that fails is a step fault and a storage fault refuses the block on this node.
Vector. computed (240 + 480 = 720). INPUT: gateway with last_heartbeat_height 1,000,
locked_stake 10,000,000,000, owner 00000000‖66×32, row height 900. EXPECTED OUTPUT: not pruned at
h = 1,720 (1,000 < 1,000 is false); at h = 1,721: owner +10,000,000,000 (event 31), gateway status 1
at 1,721.
Test cases · §10
3 cases · 3 valid
A gateway last beating at 1,000, at height 1,720
Loading the test widget…
The same at height 1,721
Loading the test widget…
A genesis gateway row is never pruned
Loading the test widget…
Defects to match. A genesis row (block_height 0) is never pruned.
11. Stored-file rent (P8), the storage-proof tally (P11) and the archive reward (A)
Purpose. An implementation charges stored files and pays the nodes that prove they hold the pieces.
Inputs. P8: the period = L and the rate dataset_storage_cost_per_mib; current stored_file
rows that are active with h − base ≥ period (base = last_billed_height, else the row height),
ascending file_root. P11: storage_proof_epoch_blocks E (testnet 240 / devnet 10),
storage_replication 5, oracle_quorum 3; the storage_proof rows of the epoch that just closed;
the registry as of the previous block. A: the archive's sampled chunks of the epoch and
snapshot_reward_share_ppm (100,000 = 10 % of the longevity pool).
Output and effect. P8: rent = max(1, ceil(total_size / 1,048,576)) × cost_per_mib; deposit ≥
rent → deposit −rent, last_billed_height = h, the storage pool 00000000‖"ZBCSTORE" (padded to
36) +rent (row event 69 on the pool); else the file is pruned (status 1, deposit 0) and a remaining
deposit goes to the longevity pool (event 50). P11 (11 §7): only at h mod E = 0 and h ≥ 2E;
epoch = h div E − 1; the pieces proved in that epoch, less the archive's sampled chunks (A pays
those; an archive or sample that cannot be read is a step fault); seed = the hash of block epoch × E (unreadable → step fault); expected holders = the replica selection of 11 §5 over the node keys
of the registry as of the previous block (unreadable → step fault), 5 per piece; submissions = that
epoch's proofs whose prover is a typed node-key account (00000000‖node key) of a registered node
(a failed registry read → step fault; a node not found → ignored); the tally at quorum 3; an
unconfirmed verdict (below the quorum, a tie) pays nobody; each honest holder that earns (20 §7:
mature, not missing, not suspended) gets pay = min(reward, the storage pool's confirmed balance) —
reward = the active files' rent per epoch over the proofs expected per epoch (rule
duty_fee_free) — pool −pay and owner +pay as an incoming payment, both rows event 19; an outvoted
submitter only loses its reward (no score is charged). A (before the block is stored): at each
storage-epoch boundary the honest holders of the archive's sampled chunks share
snapshot_reward_share_ppm of the longevity pool, those that do not earn none (event 77); a failed
read of the archive, the seed block or a holder's owner account is a step fault (11, 26).
Rule activation. survival_field, duty_fee_free, small_n_measurement,
storage_tally_no_penalty (height 0 everywhere).
Rejections and errors. A failed read of who earns, of P11's seed block, registry or proof rows, or of A's archive, sample or owners refuses the block; so does a storage fault in a P8 or P11 payment. P8 cuts a deposit only after its credit is made, and P11 debits the pool and credits the owner together or not at all.
Vector. computed (testnet rate 5,000,000). INPUT: file of 1,500,000 bytes, deposit
12,000,000, due. EXPECTED OUTPUT: rent 2 × 5,000,000 = 10,000,000; deposit 2,000,000; storage pool
+10,000,000 (event 69). Next period: 2,000,000 < 10,000,000 → pruned, 2,000,000 to the longevity pool
(event 50). A file of 10 bytes pays 5,000,000 (one MiB minimum). P11 at h = 480 (E = 240) tallies
epoch 1 with the hash of block 240 as seed.
Test cases · §11
4 cases · 4 valid
A file of 1,500,000 bytes with a deposit of 12,000,000
Loading the test widget…
The next period with 2,000,000 left
Loading the test widget…
A file of 10 bytes pays one MiB
Loading the test widget…
P11 at height 480 tallies epoch 1 seeded by block 240
Loading the test widget…
Defects to match. 11.
12. Longevity rent (P9) and the longevity payout (P10)
Purpose. An implementation draws rent from funded longevity records.
Inputs. period = longevity_billing_period_blocks if set (no live genesis sets it), else
main_snapshot_interval, else 5,760; current longevity rows with deposit > 0,
free_until_height < h, paid_through_height ≤ h − period, ascending target id; the deposit rows
and votes (13 §2).
Output and effect. P9, exactly 13 §6: rent = ceil(payload_bytes × cost_per_mib_locked / 1,048,576) (1 when either factor ≤ 0; saturating), take = min(rent, deposit), deposit −take,
paid_through_height = h; when every payer with money left has now voted, the record closes and its
rest goes to the pool (event 50); a new record version; the sum of the takes credits the pool
00000000‖"ZBCLONGV" once (row event 38, +sum). P10 does nothing: the pool pays a per-block slice in
the reward lottery instead (rule longevity_continuous, 21 §2, event 39).
How to compute it. As stated.
Rule activation. longevity_continuous (height 0 everywhere).
Rejections and errors. None.
Vector. computed. INPUT: record of 500 payload bytes, cost_per_mib_locked 5,000,000, deposit
3,000, due. EXPECTED OUTPUT: rent ceil(2,500,000,000 / 1,048,576) = 2,385; deposit 615; pool +2,385
(event 38). Next period: take = min(2,385, 615) = 615, deposit 0.
Test cases · §12
2 cases · 2 valid
A record of 500 payload bytes with a deposit of 3,000
Loading the test widget…
The next period takes the rest
Loading the test widget…
Defects to match. 13 §6; the rent of a record is drawn in full at every due block even when the
deposit covers only part (the last draw takes the rest).
13. Oracle resolution (P12), bridge deposits and withdrawals (P13–P14), the price count (P15), release governance (P15b)
Purpose. An implementation turns attestations into results, mints, burns, price changes and release decisions.
Inputs. The counted registered nodes at the previous height (17 §1: registered, not suspended); the
registry floor max(3, min_registry_size) (testnet 7 / devnet 3); bridge_quorum_num/den 2/3; the
oracle_attestation rows whose event has no oracle_result; the event-id prefixes ZBRDEP1:,
ZBWDR1:, ZBCGOV1:, ZBCREL1:; BRIDGE_EVENT_IDLE_WINDOW 720; the release-vote window
172,800 blocks and the authority delay 40,320 blocks (17 §6); the cycle length L; the survival
flag of h and the survival_state rows (19 §10).
Output and effect. The survival-adjusted age of a height a at height h is (h − a) − (the number of survival_state rows with height in (a, h] and active = 1), floored at 0: the
survival heights are not counted. P12 (17 §4): every unresolved event id except those four
prefixes (the archive's ZBCSNAP1: snapshot attestations included), only when the counted
registered nodes meet the floor: the attestations tallied in stored order counting only the
counted registered nodes' attester accounts; the first value reaching ceil(n × 2 / 3) is written
to oracle_result, and every pending trigger bound to the event (ascending trigger id) pays its
recipient from the owner (row event 23) and is marked fired, whatever the value. P13–P14 (34):
the bridge deposits and withdrawals whose newest attestation's survival-adjusted age is at most
720 resolve over the counted registered nodes under the same floor (a deposit that would raise a
wrapper's mints of the last day above max(1 coin, 10 % of supply) needs every counted registered
node, rule governance_window). P15 (17 §5): at the cycle's last block, when the survival flag
of h is false, each governable price moves to the capped average (§5) of the counted registered
nodes' latest votes of the cycle; a price whose new value cannot be written refuses the block;
when the flag of h is true the count is skipped and the cycle's votes lapse (an unreadable flag
is a step fault). P15b (17 §6): the ZBCREL1: vetoes and authority proposals that have a vote
whose survival-adjusted age is within 172,800 blocks; each is tallied over every attestation from
its oldest such vote on, at two thirds of the larger of the counted registered nodes now and at
the block before that oldest vote; an authority proposal only once its oldest counted vote's
survival-adjusted age is at least 40,320 blocks. A resolved authority proposal whose address is a
full-key account form or a kind that cannot sign (rule canonical_account_forms), the current
authority or not a valid address replaces nothing: the event stays resolved and the authority stays
(17 §6). P12, P13, P14 and P15b do not run while the
survival flag of h is true: no new AttestEvent lands (the frozen set, 19 §10) and the
attestations and votes already stored stay pending; they are tallied at the first block whose
flag is false, where the adjusted ages above make a freeze longer than a window harmless. A
storage fault in a resolution, or a failed read of the events, the previous block, the registered
nodes, the votes or the survival rows, refuses the block.
Rule activation. oracle_full_registry_quorum, oracle_registered_only, quorum_floor,
release_registry_veto, governance_window, canonical_account_forms (the authority address)
and survival_mode (the P15 skip, the P12–P14 and P15b pause, the adjusted ages): active from
height 0 on every chain.
Rejections and errors. As stated.
Vector. computed. INPUT: 7 counted registered nodes, floor 7 (testnet), event X:1 with 5 attestations of
value 01 by counted registered nodes. EXPECTED OUTPUT: quorum ceil(14 / 3) = 5 reached → oracle_result
(X:1, 01, h). With 6 counted registered nodes → nothing resolves (6 < floor 7). With 11 of them → quorum 8.
INPUT: P15 at h = 172,800 (testnet), flag of h true. EXPECTED OUTPUT: no consensus_parameters change,
no consensus_parameter_change row. INPUT (an AttestEvent cannot land while the flag is true, so
the quorum is reached by the registry shrinking): the event X:1 with 5 attestations of value 01
by counted registered nodes, all mined below h − 1; 8 counted registered nodes as of h − 2, 7 as
of h − 1 and of h (a node that did not attest is suspended at h − 1); flag of h true, flag of h + 1
false. EXPECTED OUTPUT: nothing resolves at h − 1 (quorum ceil(16 / 3) = 6 > 5); nothing at h (P12
paused, although ceil(14 / 3) = 5 is met); oracle_result (X:1, 01, h + 1). INPUT: a ZBCREL1:veto:0.6.2 vote cast at height 1,000; the flags of
heights 1,001 … 180,000 true, 180,001 false. EXPECTED OUTPUT: at h = 180,001 the vote's adjusted
age is 179,001 − 179,000 = 1 ≤ 172,800: it counts (without the adjustment it would have expired
at 173,801). INPUT: a ZBCREL1:authority:… proposal whose oldest vote is at 1,000 with 100
survival heights among 1,001 … 41,320 and none after. EXPECTED OUTPUT: not tallied at 41,320
(adjusted age 40,220 < 40,320); tallied from 41,420. INPUT: a ZBCREL1:authority:<hex> proposal
whose <hex> is 04000000 followed by a 64-byte key (a full-key Ethereum form), past its delay
and at its quorum at h. EXPECTED OUTPUT: the event's oracle_result row is written at h; the
release authority is unchanged (the proposal names an account that can never sign).
Test cases · §13
10 cases · 8 valid · 2 invalid
Seven counted registered nodes, five attestations
Loading the test widget…
Six counted registered nodes under a floor of 7
Loading the test widget…
Eleven counted registered nodes
Loading the test widget…
The price count at 172,800 in survival mode
Loading the test widget…
A quorum met at a survival height resolves at the first height out of it
Loading the test widget…
A veto vote cast at 1,000 across 179,000 survival heights still counts at 180,001
Loading the test widget…
An authority proposal with 100 survival heights since its oldest vote
Loading the test widget…
A resolved authority proposal naming a full-key Ethereum form replaces nothing
Loading the test widget…
A resolved authority proposal naming a ZBC account replaces the authority
Loading the test widget…
A resolved authority proposal naming the current authority replaces nothing
Loading the test widget…
Defects to match. (1) An event's triggers fire on any resolved value. (2) A malformed deposit
value closes the event without a mint (34). (3) The idle window makes a deposit or withdrawal event
whose attestations are all older than 720 blocks (survival-adjusted) unresolvable until a keeper
attests again (a new or replacing attestation raises its newest height, 34 §7), while P12 would
still resolve any other event. (4) A trigger fired by P12 whose credit is refused for a
deterministic reason is marked fired and its amount is neither paid nor pooled (the fallback of
§9 is not applied on this path).
14. The prune (P16) and the snapshot trigger
Purpose. What an implementation deletes after a block, and what starts a snapshot.
Inputs. 13 §8; main_snapshot_interval, main_snapshot_min_height (testnet 172,800 / 760;
devnet 240 / 80).
Output and effect. Exactly 13 §8 (the horizons shared with the snapshot: the receipt horizon,
the rollback floor min(receipt horizon, tip − max_rollback_height), the vote and release windows;
transaction rows kept 6,924 blocks and the newest snapshot's recent-transactions window; block
headers kept at least 1,440 below the tip and down to 1,440 below the newest snapshot's height
(rule readiness_registry_schedule); superseded versions kept for the rollback depth; spine
manifest rows never deleted, only a node's local copies of old snapshots). The survival rows:
once the receipt horizon is above 0, a survival_state row is deleted when its height is below
h − (max_rollback_height + 120) + 1 and below the oldest height any pending event still counts:
the newest attestation of an unresolved event (parameter and release votes excepted) whose
survival-adjusted idle age is ≤ 720, and the oldest attestation of an unresolved ZBCREL1: event
whose survival-adjusted age is ≤ 172,800 + max_rollback_height (§13); a pending release vote's
own rows go only once that adjusted age is above that bound, a resolved event's rows at the
plain release horizon. In chunks of 500 rows per block. The snapshot trigger is local: when
block S with (S + main_snapshot_min_height) mod main_snapshot_interval = 0 is committed, the
node pins a read view and builds the snapshot of S from it after its stagger offset (26 §1);
the manifest it produces is what the spine anchors (25, 26).
Rule activation. 13 §8; the survival-row retention is rule survival_mode, the block window
rule readiness_registry_schedule: active from height 0 on every chain.
Rejections and errors. None; failed deletes are logged.
Vector. computed. INPUT: testnet (172,800 / 760). EXPECTED OUTPUT: snapshot heights 172,040,
344,840, … ; devnet (240 / 80): 160, 400, 640, … INPUT: devnet (max_rollback_height 60), h =
10,000, no pending event. EXPECTED OUTPUT: survival_state rows below 10,000 − 180 + 1 = 9,821
are deleted. INPUT: the same with a pending bridge deposit whose newest attestation is at 9,500
and no survival height since. EXPECTED OUTPUT: rows below 9,500 are deleted, 9,500 … 9,820 kept.
Test cases · §14
4 cases · 4 valid
Snapshot heights on the testnet (172,800 / 760)
Loading the test widget…
Snapshot heights on the devnet (240 / 80)
Loading the test widget…
Devnet, h = 10,000, no pending event: survival_state rows below 9,821 are deleted
Loading the test widget…
The same with a pending bridge deposit last attested at 9,500
Loading the test widget…
Defects to match. 13 §8.
15. Ledger rows and the consensus/local split
| Event | Row | Processor |
|---|---|---|
| 9 | sender +amount(+commission) | S1 |
| 14 | recipient +amount | S2 |
| 100 | pool −pay, player +pay; a player's refund | S3, S4, S4b |
| 84 | longevity pool +shares | S4b |
| 59 | maker +hold | S5, P8b |
| 77 | longevity pool −reward, holder +share | A |
| 17, 18, 19, 32, 50, 83 | deposit/owner −fee, 0, pool +rent, refunds, sweep, prepaid spent | P2 |
| 20, 21, 50 | issuer 0, holder/issuer +share; pool +share when a holder's credit is refused | P3 |
| 24, 25, 83, 19, 50 | account −cost, −(balance + prepaid) at a prune, +prepaid spent; pool +rent, +balance and prepaid | P4 |
| 23, 50 | recipient +amount; pool +amount when the credit is refused (P5 only) | P5, P12 |
| 28, 29, 30, 34, 50 | schedule tranches, skips, refunds; pool +leftover when its return is refused | P6 |
| 31, 50 | owner +stake; pool +stake when the credit is refused | P7 |
| 69, 50 | storage pool +rent; longevity pool +remainder | P8 |
| 19 | pool +rent / +deposit | P8b |
| 38, 50 | pool +Σ rent; pool +rest of a closed record | P9 |
| 19 | storage pool −pay, owner +pay | P11 |
No processor writes events 26, 27, 35, 36, 73 or a ZBC event 74.
Consensus: every selection condition, order, formula, rounding, write and skip above (the balances and rows after the block must match to the unit), the survival skips and pauses and the survival-adjusted ages included; the prune's horizon and bound are consensus only in that they decide which escrows S1 expires and what a snapshot carries; what a node actually deletes, the keep-everything switch and the snapshot request are local. A refusal for a failed read is local (a healthy node never takes it).
Test cases · §15
1 case · 1 valid · 1 reference
Events no processor writes
A stated value: there is nothing to compute. A compatible node shows the same value.
- never
26, 27, 35, 36, 73, ZBC 74
A question about this chapter, or a statement that does not match the network? Discuss on zoobc.pro.