On this page
  1. §0 The area in one paragraph
  2. 1. The schedule
  3. 2. Escrow expiry (S1)
  4. 3. Liquid-payment completion (S2)
  5. 4. Due solo bets, channel settlements, unstarted apps and order expiry (S3–S5)
  6. 5. The fee-scale count (P1)
  7. 6. Dataset rent (P2)
  8. 7. Token expiry settlement (P3)
  9. 8. Account rent and account pruning (P4)
  10. 9. Height triggers (P5) and timed schedules (P6)
  11. 10. Gateway pruning (P7)
  12. 11. Stored-file rent (P8), the storage-proof tally (P11) and the archive reward (A)
  13. 12. Longevity rent (P9) and the longevity payout (P10)
  14. 13. Oracle resolution (P12), bridge deposits and withdrawals (P13–P14), the price count (P15), release governance (P15b)
  15. 14. The prune (P16) and the snapshot trigger
  16. 15. Ledger rows and the consensus/local split

22 — Periodic processors

Edition 0.6.1 · verified against the reference implementation, version 0.6.1

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 testnet22-1-h-480valid

Loading the test widget…

Height 12,480 on the testnet22-1-h-12480valid

Loading the test widget…

Height 172,800: the cycle's last block22-1-h-172800valid

Loading the test widget…

Height 172,800 judged in survival mode22-1-h-172800-survivalvalid

Loading the test widget…

Height 240: P11 waits for two epochs22-1-h-240valid

Loading the test widget…

The addresses exempt from account rent22-1-rent-exemptvalidreference

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 timeout22-2-duevalid

Loading the test widget…

Escrow 7's ledger row and new version22-2-rowsvalid

Loading the test widget…

The previous block stamped exactly at the timeout22-2-not-duevalid

Loading the test widget…

A token escrow returns its units and refunds only the commission22-2-tokenvalid

Loading the test widget…

An escrow of height 12,500 at block 345,600: below the horizon, expired whatever its timeout22-2-horizonvalid

Loading the test widget…

The same escrow at block 345,599: no horizon yet22-2-horizon-earlyvalid

Loading the test widget…

The same escrow with a funded longevity record: kept22-2-horizon-fundedvalid

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 minutes22-3-duevalid

Loading the test widget…

One second early22-3-not-duevalid

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.

How to compute it. As stated; the arithmetic is in 15 and 16.

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 hold22-4-ordervalid

Loading the test widget…

An order with expiry 0 never expires here22-4-order-no-expiryvalid

Loading the test widget…

The solo payout cap of token 0 and a win of 800,000,00022-4-solo-capvalid

Loading the test widget…

Defects to match. 15 §8 (an order born expired is accepted and expired by this sweep) and 16.

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,80022-5-countvalid

Loading the test widget…

The same count at 172,800 in survival mode is skipped22-5-skippedvalid

Loading the test widget…

Height 172,799 is not the cycle's last block22-5-not-lastvalid

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 rate22-6-feesvalid

Loading the test widget…

The storage fee at the testnet rate22-6-fees-testnetvalid

Loading the test widget…

An object of 218 bytes with a deposit of 1,00022-6-owner-coversvalid

Loading the test widget…

The same with an owner balance of 3022-6-prunedvalid

Loading the test widget…

Two records of one object, written at 100 and 200: one charge, both re-clocked22-6-one-clockvalid

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 each22-7-thirdsvalid

Loading the test widget…

10 over 1, 2 and 3 units22-7-one-two-threevalid

Loading the test widget…

1,000 over 3 and 7 units22-7-three-sevenvalid

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 first22-8-coveredvalid

Loading the test widget…

Account rent not covered: the account is tombstoned22-8-tombstonevalid

Loading the test widget…

The rent of a group address of weight 284 bytes22-8-groupvalid

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,00022-9-firesvalid

Loading the test widget…

Trigger 12 at height 99922-9-earlyvalid

Loading the test widget…

Trigger 12 whose recipient's balance would overflow: paid to the longevity pool22-9-overflowvalid

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,72022-10-keptvalid

Loading the test widget…

The same at height 1,72122-10-prunedvalid

Loading the test widget…

A genesis gateway row is never pruned22-10-genesis-rowvalid

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).

How to compute it. As stated; 11 §4, §5, §7 and 26 for the archive.

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,00022-11-rentvalid

Loading the test widget…

The next period with 2,000,000 left22-11-prunedvalid

Loading the test widget…

A file of 10 bytes pays one MiB22-11-one-mibvalid

Loading the test widget…

P11 at height 480 tallies epoch 1 seeded by block 24022-11-p11-480valid

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,00022-12-rentvalid

Loading the test widget…

The next period takes the rest22-12-lastvalid

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.

How to compute it. 17, 34; the adjusted age as stated.

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 attestations22-13-quorum-7valid

Loading the test widget…

Six counted registered nodes under a floor of 722-13-below-floorvalid

Loading the test widget…

Eleven counted registered nodes22-13-quorum-11valid

Loading the test widget…

The price count at 172,800 in survival mode22-13-p15-survivalvalid

Loading the test widget…

A quorum met at a survival height resolves at the first height out of it22-13-oracle-pausevalid

Loading the test widget…

A veto vote cast at 1,000 across 179,000 survival heights still counts at 180,00122-13-veto-agevalid

Loading the test widget…

An authority proposal with 100 survival heights since its oldest vote22-13-authority-delayvalid

Loading the test widget…

A resolved authority proposal naming a full-key Ethereum form replaces nothing22-13-authority-full-keyinvalid

Loading the test widget…

A resolved authority proposal naming a ZBC account replaces the authority22-13-authority-replacedvalid

Loading the test widget…

A resolved authority proposal naming the current authority replaces nothing22-13-authority-currentinvalid

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).

How to compute it. 13 §8, 26 §1.

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)22-14-testnetvalid

Loading the test widget…

Snapshot heights on the devnet (240 / 80)22-14-devnetvalid

Loading the test widget…

Devnet, h = 10,000, no pending event: survival_state rows below 9,821 are deleted22-14-survival-rowsvalid

Loading the test widget…

The same with a pending bridge deposit last attested at 9,50022-14-survival-rows-pendingvalid

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 writes22-15-eventsvalidreference

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.