On this page
- §0 The area in one paragraph
- 1. The header fields
- 2. The header bytes
- 3. The block signature
- 4. The block hash and the block id
- 5. The block seed
- 6. The payload hash and the payload length
- 7. The transaction Merkle root
- 8. The totals and the constant fields
- 9. The cumulative difficulty
- 10. Size ceilings and the order of format checks
- 10.1 The serialized block size
- 11. The wire form
- 12. The API form
- 13. What the hash and the signature cover
05 — The block format
Out of scope the genesis block's own construction (06); the meaning and validation of published receipts beyond their bytes in the payload (23); block validity rules other than format (timing windows, the blocksmith check, the receipt rules, the transaction rules, the survival freeze: 19, 20, 23); the coinbase amount and the fee distribution (21); fork choice with the cumulative difficulty (24); the spine chain's block (25); the P2P procedures that carry blocks (27, 28); the rule-activation machinery behind the version check (29); the HTTP API in general (31)
§0 The area in one paragraph
A block is a fixed header plus three lists: transactions, published receipts, and (only on the
spine chain, 25) registry deltas and manifests. The header is serialised into 284 bytes in a
fixed little-endian layout (204 bytes for the genesis block, which carries no seed proof); the
blocksmith signs those bytes with its Ed25519 node key, the signature is appended, and the
SHA3-256 of the 348 signed bytes is the block hash; the first 8 bytes of the hash, read
little-endian, are the block id. The header commits to its contents through one field, the
payload hash, the SHA3-256 of the transaction hashes followed by the 232-byte form of every
published receipt, and through the payload length, the sum of the transactions' body lengths
and the receipts' bytes. The block seed chains the randomness of the protocol: it is the
ECVRF output over the SHA3-256 of the previous seed, and the header carries the 80-byte proof, so
no blocksmith can choose it (01 §8). A block's size, the one number every node bounds, is its
serialized size: the signed header, every signed transaction, and a fixed 1,288 bytes per
published receipt (§10.1). Three header fields travel with the block but are not under the
hash or the signature: the transaction Merkle root (derived at apply, §7), the cumulative
difficulty (a decimal string every node recomputes and must match), and the Merkle tree bytes,
which a main-chain block must leave empty. The rest of the protocol takes from this area the block
hash and id (chain identity, previous-hash links, receipts' reference hash, transaction ids'
block), the seed (blocksmith selection, lotteries, the apps draws), the payload hash (receipt
validation), the size, and the declared totals (21). An implementation that produces the header
bytes, the payload digest, the seed and the size exactly as specified here, and refuses exactly
what §10 refuses, is format-compatible; everything else about a block's validity is in 19.
1. The header fields
Purpose. The complete list of what a block carries, with each field's exact type.
Inputs. Produced by the blocksmith (20) from the previous block, the clock, the pool (04)
and the receipt store (23).
Output and effect. The fields below. "Hashed" means inside the 348 signed bytes (§2); "checked" means the validator recomputes or constrains it (§10).
| Field | Type / width | Hashed | Checked | Meaning |
|---|---|---|---|---|
version |
u32 | yes | ≠ 0, and ≥ the newest active bundle (§8) | the blocksmith's bundle id: 601 from a 0.6.1 build (major × 10,000 + minor × 100 + patch), 1 at genesis |
timestamp |
i64, Unix seconds | yes | yes (19, 20) |
the block's time |
total_amount |
i64 | yes | no | written 0 by the blocksmith; nothing constrains it |
total_fee |
i64 | yes | = Σ declared fee of the transactions, in order, i64 wrapping add |
sum of declared fees (04) |
total_coinbase |
i64 | yes | = the emission schedule's amount for the block's interval; 0 at height 1 (§8) | the coinbase the blocksmith claims |
payload_length |
u32 (serialised as 8 bytes) | yes | = §6, ≤ max_block_size_bytes |
bytes of bodies + receipts |
payload_hash |
32 bytes | yes | = §6 | digest of the contents |
blocksmith_public_key |
32 bytes | yes | 32 bytes; a registered node per 20 |
the blocksmith's Ed25519 node key |
block_seed |
64 bytes | yes | §5 | the ECVRF output (01 §8) |
block_seed_proof |
80 bytes | yes | §5 | the ECVRF proof the validator verifies; empty only at genesis |
previous_block_hash |
32 bytes | yes | = the previous block's hash | link |
block_signature |
64 bytes | hashed, not signed | §3 | Ed25519 over the 284 unsigned bytes |
block_hash |
32 bytes | — | = SHA3-256 of the signed bytes | identity |
id |
i64 | — | = §4 of the hash, ≠ 0 | numeric identity |
height |
u32 | no | = previous + 1 | position |
cumulative_difficulty |
decimal string | no | = §9 | fork-choice weight |
merkle_root |
32 bytes | no | a non-empty one = §7; stored as §7 whatever arrived | transaction tree root |
merkle_tree |
bytes | no | must be empty on the main chain (rule block_size_serialized, §10.1) |
unused on the main chain |
reference_block_height |
u32 | no | no | 0 on the main chain; spine only (25) |
transactions |
list | through payload_hash |
19 |
in block order; each gets height = block height and transaction_index = its 0-based position when applied |
published_receipts |
list | through payload_hash (232 bytes each) |
23; proof bounds §10.1 |
in block order (published_index 0…n−1) |
spine_public_keys, spine_block_manifests, reference_commitment, spine_refusals |
lists / bytes | 25 |
25 |
empty on the main chain |
transaction_ids |
list of i64 | no | — | wire-only (§11): the ids of transactions when a broadcast omits their bodies |
Stored form. A node keeps one row per main-chain block (state object main_block, 07): every
field above except the lists and transaction_ids; height and block_hash are each unique,
and the node looks blocks up by height, by hash and by id; merkle_root holds the derived root (§7), merkle_tree is stored empty, and the
transactions and receipts are rows of their own tables, keyed by (block height, index). A pop-off
(24) deletes every row with a height above the target.
How to compute it. Each field is specified in its own section below; the blocksmith fills them
in this order: version = its bundle id (601), height, timestamp, previous_block_hash,
block_seed and block_seed_proof (§5), blocksmith_public_key, total_coinbase (21), the
transaction list (04 §10) or none, the receipt list (23), total_amount 0, total_fee (sum),
merkle_root (§7), payload_hash and payload_length (§6), cumulative_difficulty (§9); then
it trims the transactions to the size limit (§10.1), recomputes the totals, the root and the
payload, and signs (§3); the hash and the id follow (§4).
Rule activation. None for the field list.
Rejections and errors. See §10.
Vector (computed: an empty block 1). The vectors of §2–§5, §8, §9 and §12 share one block,
built from these fields: version 601, height 1, timestamp 1,793,509,042 (15 s after the
genesis timestamp of the TestNet file, 06 §12), total_amount 0, total_fee 0,
total_coinbase 0 (height 1, §8), payload_length 0, payload_hash 32 zero bytes, no
transactions and no receipts, merkle_root 32 zero bytes, merkle_tree "",
reference_block_height 0, cumulative_difficulty "1000000" (§9), previous_block_hash = the
genesis hash of the shipped TestNet file, 3a2897e7…863d (06 §3), blocksmith_public_key =
the key of the seed 01 × 32 (8a88e3dd…6f5c, the VRF vector key of 01 §8), block_seed and
block_seed_proof = the block-1 VRF vector of 01 §8 (b). The blocksmith key is a test key, not
a registered node of that file, and the launch restamps the genesis: the block is a format vector,
not a block of any chain. Its bytes, signature, hash and id are in §2–§4.
Test cases · §1
1 case · 1 valid · 1 reference
The header fields of the block 1 of §1
15 s after the genesis timestamp of the TestNet file, on its genesis hash (06 §3); a format vector, not a block of a chain.
A stated value: there is nothing to compute. A compatible node shows the same value.
- version
601- height
1- timestamp
1793509042- total_amount
0- total_fee
0- total_coinbase
0- payload_length
0- payload_hash
0000000000000000000000000000000000000000000000000000000000000000- transactions
0- merkle_root
0000000000000000000000000000000000000000000000000000000000000000- merkle_tree
- reference_block_height
0- cumulative_difficulty
1000000- previous_block_hash
3a2897e7c5ad6143429bab33a92d14d11ffd6fc281f2b62a6fd6b49c183b863d- blocksmith_public_key
8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c
Defects to match. total_amount is signed and hashed but never validated and never computed:
an implementation must accept any value in a received block and write 0 in its own blocks to
match the reference's bytes.
2. The header bytes
Purpose. The one serialisation of a header: what is signed and what is hashed.
Inputs. The header fields of §1.
Output and effect. The unsigned bytes (284 bytes, the input of the block signature) and the
signed bytes (348 bytes, the input of the block hash). All integers little-endian. The genesis
block carries no seed proof: its proof row is omitted and its two lengths are 204 and 268 (06).
| Offset | Length | Field | Encoding |
|---|---|---|---|
| 0 | 4 | version |
u32 LE |
| 4 | 8 | timestamp |
i64 LE (two's complement bytes) |
| 12 | 8 | total_amount |
i64 LE |
| 20 | 8 | total_fee |
i64 LE |
| 28 | 8 | total_coinbase |
i64 LE |
| 36 | 8 | payload_length |
u32 widened to u64, LE (bytes 40–43 are zero) |
| 44 | 32 | payload_hash |
raw |
| 76 | 32 | blocksmith_public_key |
raw |
| 108 | 64 | block_seed |
raw |
| 172 | 32 | previous_block_hash |
raw |
| 204 | 80 | block_seed_proof |
raw; omitted entirely when empty (genesis), so such a header ends at 204 |
| 284 | 64 | block_signature |
raw, signed form only (at offset 204 when the proof is omitted) |
The byte fields are appended as carried: a header whose payload_hash is not 32 bytes, or
whose seed is not 64 bytes, produces a shorter or longer buffer rather than an error. The seed
proof is appended only when non-empty and always after previous_block_hash, so the offsets of
the fields an equivocation report reads (the blocksmith key at 76, the previous hash at 172) are the
same with or without it (35). The signed form requires a non-empty signature.
How to compute it. Concatenate the fields in the order of the table. For the unsigned form stop
after block_seed_proof (after previous_block_hash when the proof is empty).
Rule activation. Rule seed_vrf (at 0 on every chain) puts the proof in every block above
genesis.
Rejections and errors. None of its own.
Vector (computed, the block 1 of §1). Input: the fields of §1. Expected output, the 284
unsigned bytes (spaces separate fields):
59020000 (version 601) b2c6e66a00000000 (timestamp 1,793,509,042) 0000000000000000
(total_amount) 0000000000000000 (total_fee) 0000000000000000 (total_coinbase 0)
0000000000000000 (payload_length 0) 00 × 32 (payload_hash of an empty block)
8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c (blocksmith key)
0aaaaa1285e87f89b1bddb73cebe33ee2966bf8d3291c4032bfa0445fa8aa242f50ec37f4d2315be1345bbbb2ed60ee130002e92a42a10c54e00018f69fd85b3
(seed) 3a2897e7c5ad6143429bab33a92d14d11ffd6fc281f2b62a6fd6b49c183b863d (previous hash)
542529a7c6e4557c0b133b605bfeda1850e8a6fcee80fa47fd892482afa6f4c8cd092d802ef89d6748dd49437f9a3b385c4869b410f02c864a3dc81b3d2d766796fc724a3dca71fe10e5c0b80cfa1d0b
(seed proof). The signed bytes append the signature of §3 (348 bytes).
Test cases · §2
1 case · 1 valid
The 284 unsigned header bytes of the block 1
Loading the test widget…
Defects to match. None.
3. The block signature
Purpose. Proves the block was made by the holder of the blocksmith key named in the header.
Output and effect. block_signature, 64 bytes: a standard Ed25519 signature over the
unsigned header bytes directly — no prefix, no genesis binding, no pre-hash (unlike
transactions, 02 §1). Verification: Ed25519 verify of those bytes under blocksmith_public_key,
with the strict checks of 02 §3.1.
How to compute it. sig = Ed25519_sign(sk_node, unsigned_bytes), the 284 bytes of §2.
Rule activation. None.
Rejections and errors. A signature that is not exactly 64 bytes → "Invalid signature size";
a blocksmith key not 32 bytes → "Invalid public key size"; a signature that does not verify →
"Invalid block signature". Each makes the block invalid.
Vector (computed, the block 1 of §1; the signing key is the seed 01 × 32). Input: the 284
bytes of §2 and the key 8a88e3dd…6f5c → the signature
6b9a7c6a325346f802dc42d4433792fa3f7aaaf20400498d84747b92de35d1ed5edc621482a2b6cf75e9f00866137d8d6fbe96b2107f996d5b6c55abe679f50c
(Ed25519 signing is deterministic, so any implementation produces these bytes), and it verifies.
Invalid input: the same signature checked over the first 204 bytes only (the header without the
seed proof) → does not verify ("Invalid block signature").
Test cases · §3
3 cases · 3 valid
The block 1 signed with the seed 01 x 32 (Ed25519 is deterministic)
Loading the test widget…
The block 1's signature verifies over its 284 unsigned bytes
Loading the test widget…
The same signature over the first 204 bytes only does not verify
Loading the test widget…
Defects to match. None.
4. The block hash and the block id
Purpose. The block's identity: what the next block links to, what receipts reference, what the API and the P2P protocol name a block by.
Inputs. The 348 signed bytes of §2 (the unsigned bytes and the signature).
Output and effect. block_hash = SHA3-256(signed_bytes), 32 bytes. id = the first 8 bytes
of the hash read as a little-endian two's-complement i64 (byte 0 least significant). An id of 0
is invalid.
How to compute it. 1. signed = unsigned ‖ signature. 2. hash = SHA3-256(signed).
3. id = Σ_{k=0..7} hash[k] × 256^k, interpreted as i64 (values ≥ 2^63 become negative).
Rule activation. None.
Rejections and errors. A carried block_hash that differs from the recomputed one →
"Invalid block hash"; a hash shorter than 8 bytes → "InvalidID: block hash too short"; a
derived id of 0 → "InvalidID: block ID is zero"; a carried non-zero id that differs from the
derived one → "InvalidID: block ID mismatch". A receiver that gets id 0 on the wire derives it
from the hash before validating.
Vector (computed, the block 1 of §1). Input: the 348 signed bytes of §2–§3 → block_hash
c056a43b22436827a0b979d4725c579e6768fba0bab7c8941e69142fcf29f6fb, id = LE i64 of
c056a43b22436827 = 2,839,593,379,365,672,640 (the top bit of byte 7 is clear, so the id is
positive). Block 2 would link to it through its previous_block_hash. Invalid input: the same
block carrying id 1 → "InvalidID: block ID mismatch".
Test cases · §4
4 cases · 2 valid · 2 invalid
The block 1's hash and id from its 348 signed bytes
Loading the test widget…
A block id read from the hash
Loading the test widget…
The block 1 carrying id 1
Loading the test widget…
A hash whose first 8 bytes are zero gives id 0
Loading the test widget…
Defects to match. None.
5. The block seed
Purpose. A verifiable random value per block that nobody can choose: the input of blocksmith
selection (20), the coinbase lottery (21), receipt selection (23) and the apps draws (16).
Inputs. The previous block's block_seed (64 bytes; the genesis block's seed is defined in
06); the blocksmith's Ed25519 node key; the 80-byte block_seed_proof the header carries.
Output and effect. block_seed (64 bytes) is the ECVRF output over
alpha = SHA3-256(previous_block.block_seed) under the blocksmith key, and block_seed_proof (80
bytes) is the proof; the full primitive, the proof layout (Gamma(32) ‖ c(16) ‖ s(32)) and the
output SHA-512(0x03‖0x03‖8·Gamma‖0x00) are in 01 §8. Every proof for one (key, alpha) has the
same output, so the blocksmith cannot choose the seed. The validator requires the 80-byte proof (an
empty one is invalid), verifies it under blocksmith_public_key over alpha, and refuses a
block_seed that is not the proof's output.
How to compute it. 1. alpha = SHA3-256(previous seed, 64 bytes). 2. proof = ECVRF_prove(sk_node, alpha) and seed = ECVRF_proof_to_hash(proof) (01 §8).
Rule activation. seed_vrf, active from height 0 on every chain. A node-key change takes
effect 120 blocks after its block (09), so a blocksmith cannot steer a later seed with a
pre-signed rotation.
Rejections and errors. For height > 0: a seed not 64 bytes → "Invalid block seed size: expected 64 bytes, got N"; a blocksmith key not 32 bytes → "Invalid blocksmith public key size for block seed validation"; a proof not 80 bytes → "Block seed: rule seed_vrf requires the 80-byte VRF proof in the header (got N bytes)"; a proof that does not verify under the key →
"Block seed: the VRF proof does not verify under the blocksmith key (...)"; a seed that is not
the proof's output → "Block seed: the seed is not the VRF proof's output". Height 0 is not
checked.
Vector (computed, the block 1 of §1; the same vector as 01 §8 (b)). Input: the genesis
block's seed, 64 zero bytes (06 §4), the key 8a88e3dd…6f5c and the proof 542529a7…1d0b →
alpha = 070fa1ab6fcc557ed14d42941f1967693048551eb9042a8d0a057afbd75e81e0, the proof verifies
(encode to curve at counter 34) and its output is the seed 0aaaaa12…85b3. Because block 0's seed
is all zeros on every chain, every chain's block 1 has this alpha; the seed differs with the
blocksmith's key. Invalid input: the block carried with an empty proof → "Block seed: rule seed_vrf requires the 80-byte VRF proof in the header (got 0 bytes)"; carried with the seed's
first byte changed to 0b → "Block seed: the seed is not the VRF proof's output".
Test cases · §5
4 cases · 1 valid · 3 invalid
The block 1's seed is the ECVRF output over SHA3-256 of the genesis block's 64 zero seed bytes
Loading the test widget…
The block 1 carried with an empty proof
Loading the test widget…
The block 1 carried with the seed's first byte changed to 0b
Loading the test widget…
A 32-byte seed
Loading the test widget…
Defects to match. None.
6. The payload hash and the payload length
Purpose. The one commitment of the header to the block's contents.
Inputs. The transactions in block order (each one's 32-byte transaction_hash, 03 §9, and
its declared body length); the published receipts in block order (eight fields each, 23).
Output and effect. payload_hash (32 bytes) and payload_length (u32).
payload_data = tx_hash_0 ‖ … ‖ tx_hash_{n−1} ‖ receipt_bytes_0 ‖ … ‖ receipt_bytes_{m−1}.payload_hash = SHA3-256(payload_data), or 32 zero bytes whenpayload_datais empty (no transactions and no receipts).payload_length = Σ body_length(tx_i) + Σ len(receipt_bytes_j)(u32, wrapping). The transaction term is the body length only (thebody_lengthfield of the envelope), not the envelope size.
receipt_bytes of a published receipt, 232 bytes when every field has its nominal size:
| Offset | Length | Field | Encoding |
|---|---|---|---|
| 0 | 32 | sender_public_key |
raw |
| 32 | 32 | recipient_public_key |
raw |
| 64 | 4 | reference_block_height |
u32 LE |
| 68 | 32 | reference_block_hash |
raw |
| 100 | 4 | datum_type |
u32 LE |
| 104 | 32 | datum_hash |
raw |
| 136 | 32 | rmr |
raw, as carried (an empty rmr contributes 0 bytes here) |
| 168 | 64 | recipient_signature |
raw |
The fields are appended as carried; payload_length counts the actual bytes appended. The
published receipt's other fields (intermediate_hashes, block_height, published_index,
rmr_linked, rmr_linked_index) are not in the digest; their size is bounded by §10.1.
How to compute it. As stated; the transactions' hashes are those of 03 §9 (SHA3-256 of the
signed envelope), so a block that carries only transaction ids on the wire (§11) cannot be checked
until the bodies are fetched.
Rule activation. None.
Rejections and errors. payload_length ≠ recomputed →
"InvalidBlockPayload: length mismatch (calculated=X, block=Y)"; payload_hash ≠ recomputed →
"InvalidBlockPayload: hash mismatch". Both make the block invalid; the validator runs them after
the size checks (§10).
Vector (computed). Input: one transaction, the version-3 SendZBC of 02 §1 (hash
058c3078711492773af075a3b4dd07b44a7e17bd3b3ea985f64677af96a4e467, body length 8), no receipts →
payload_hash 6a528d7fa9daed78d8ff573b0459d0b55c5518f5a0116c2a23c738cd9433f296, payload_length
8. Input: the same transaction and one receipt of 232 bytes
02a50719c01d3b81030d5bb866b25e69f15668de15160ba51b43cd0c1b352ca2 (sender)
eb89f581920cac9343663a33911d76cef5c89390f25865651d902792b881ad65 (recipient) 04000000
(reference height 4) 5ed806141b8b1c9ec9bd826ceca62f2ac26f286134380088dafb258ea60a3b0d (reference
hash: an example 32-byte value) 01000000 (datum type 1) 5ed80614…3b0d (datum hash) 11 × 32 (rmr) 22 ×
64 (signature; any 64 bytes for this digest test) → payload_hash
4bcf1f0a1cce081f9c4a1e6845dc8a94d1bb4d880c6de2768a80273534d765ce, payload_length 240. The same
receipt with an empty rmr → payload_hash
6471dd1948df282060ae6f24b0519b4892a34725fe788869b6bf30c1366fba88, payload_length 208. Empty
block → 32 zero bytes, 0 (the block 1 of §1). A block with one 24-byte-body transaction and ten
receipts of 232 bytes → payload_length 2,344. Invalid input: the first vector carrying
payload_length 9 → "InvalidBlockPayload: length mismatch (calculated=8, block=9)".
Test cases · §6
6 cases · 5 valid · 1 invalid
The payload of one transaction
Loading the test widget…
The payload of one transaction and one receipt
Loading the test widget…
The same receipt with an empty rmr
Loading the test widget…
An empty block
Loading the test widget…
One 24-byte-body transaction and ten receipts of 232 bytes
Loading the test widget…
The one-transaction payload carrying payload_length 9
Loading the test widget…
Defects to match. A receipt whose rmr is empty contributes 200 bytes here but is hashed as
a Merkle leaf with 32 zero bytes in its place (23); the two serialisations of a receipt differ in
that case. A receipt the reference publishes always carries a 32-byte rmr (23), so the case
arises only for a copy altered in transit, which the payload hash refuses.
7. The transaction Merkle root
Purpose. A root over the transaction hashes, carried for clients; not part of the block hash.
Inputs. The transactions' hashes in block order.
Output and effect. merkle_root (32 bytes): 32 zero bytes when there are no transactions; the
single hash itself when there is one; otherwise the root of a binary SHA3-256 tree. The validator
recomputes it only when the carried field is non-empty, and then it must match; the apply path
stores the recomputed root whatever arrived (the field is outside the hash and the signature, so
a relay could change it in transit; every node holds the same derived value, the one the spine
blocksmith copies into its block, 25 §1). merkle_tree is never filled for a main-chain block
(empty bytes; empty in the stored row; "" in the JSON); a copy that carries one is refused
(§10.1).
How to compute it. Level 0 = the hashes in order. While a level has more than one node: pair
nodes left to right, parent = SHA3-256(left ‖ right); an odd last node is paired with
itself, SHA3-256(last ‖ last). The root is the single node of the top level. (The same tree
serves receipt batches, 23.)
Rule activation. None.
Rejections and errors. A non-empty merkle_root that differs from the recomputed one →
"Invalid merkle root". An empty one is accepted without a check and replaced by the computed
root at apply.
Vector (computed). Let h1 = 058c3078…e467 (the transaction of 02 §1), h2 =
4c337c69…ab08 (the version-2 transaction of 03 §1), h3 = SHA3-256("tx3") =
fe39bb442ba395d308ffd517932f961bfa80365f3888fea2911ae73ccd9f586f, h4 = SHA3-256("tx4") =
5c4065ebfa7de0fa63edfcbe5c773b3ea942bc9563e6b5d1244a47eef330f988, h5 = SHA3-256("tx5") =
70fbd2a3fc8b2b2191003e42ba58f9ef11ec79691161faf9427fd6e597809c58. One transaction [h1] →
merkle_root = h1. Two [h1, h2] → SHA3-256(h1 ‖ h2) =
de9518925e3fc4cf9ab25988e753145b39b3d39e7c4f87c02715fae131525ba3. Five [h1, h2, h3, h4, h5]
(the fifth paired with itself at levels 0 and 1) →
4b6a6d132cbfb25c02b79ee93062deacc52a7f92e78fb47c97749cc8210eb2dc. No transactions → 32 zero
bytes (the block 1 of §1). Invalid input: the two-transaction block carrying merkle_root
00…01 → "Invalid merkle root".
Test cases · §7
5 cases · 4 valid · 1 invalid
One transaction: the root is its hash
Loading the test widget…
Two transactions: SHA3-256 of the two hashes
Loading the test widget…
Five transactions: the fifth paired with itself at levels 0 and 1
Loading the test widget…
A block without transactions (the block 1)
Loading the test widget…
The two-transaction block carrying the root 00…01
Loading the test widget…
Defects to match. The field is outside the hash and the signature, so a relay can alter it without invalidating the signature; the check only forces consistency, and the stored value is the derived one. An implementation must carry it exactly (its own blocks) and check it only when present (received blocks).
8. The totals and the constant fields
Purpose. What the summed and fixed header fields mean and which are constrained.
Inputs. The transactions (fee), the coinbase computation (21), the blocksmith's bundle id,
the rule-activation table and its readiness state (29).
Output and effect. total_fee = the sum of the declared fees of the block's transactions, in
block order, as a wrapping i64 addition (no overflow check); 0 for an empty block. The validator
recomputes it the same way and requires equality ("Block total fee mismatch"). total_coinbase
must equal schedule(block.timestamp) − schedule(previous.timestamp), the cumulative emission
curve of 21 evaluated with the genesis timestamp and the chain's total distribution, and be
exactly 0 at height 1; an empty block carries the full schedule like any other. At apply
(height > 0) a negative value is refused ("Negative total_coinbase"), a value above the schedule
is refused ("total_coinbase exceeds emission schedule: got N, max M"), and a value below it too
("total_coinbase below emission schedule: got N, schedule M"). total_amount = 0 from the
blocksmith, unconstrained. reference_block_height = 0 on the main chain.
version = the blocksmith's bundle id, major × 10,000 + minor × 100 + patch of its release:
601 for 0.6.1, 1 at genesis. A value of 0 is refused ("Invalid block version"). Under rule
activation_readiness_gate a version below the newest active bundle at the block's height is
refused ("Block version N is below the active bundle M (activation_readiness_gate)"). The newest
active bundle at a height is the largest bundle id among the rules active there; 24 rules carry
bundle id 601 (29) and every genesis file lists them at height 0, so on every chain the newest
active bundle is 601 from height 1 and a block's version must be at least 601: a block of
version 600 is invalid everywhere. A rule listed at 0 in the genesis is exempt from the readiness
gate (it is active from genesis without signals); a later bundle, registered in the release
registry after launch, is readiness-gated: its rules switch on at the first height h* at or
after its registry floor (the earliest unrevoked registration of its release plus
ACTIVATION_FLOOR_BLOCKS = 5,760 blocks; the binary's compiled height is not consulted, rule
readiness_registry_schedule) at which ⌈2R/3⌉ distinct counted registered nodes (R = registered
and not suspended at h* − 1), as blocksmiths, have produced a block carrying version ≥ the
bundle id inside the signal window of the last min(max(720, 5R), 1,440) blocks (29). The gate,
the decision row it writes and the window are specified in 29.
How to compute it. As stated.
Rule activation. activation_readiness_gate, readiness_registry_schedule and
readiness_decision_state: active from height 0 on every chain. The coinbase equality has no rule.
Rejections and errors. total_fee mismatch, version 0 and a version below the active bundle
as above, and the coinbase bounds (checked at apply); each makes the block invalid.
Vector (computed). The block 1 of §1: version 601, total_coinbase 0, total_fee 0,
total_amount 0. A block with two transactions declaring fees 5,000,000 and 5,000,000 →
total_fee 10,000,000. Invalid inputs: the block 1 of §1 carrying version 600 → "Block version 600 is below the active bundle 601 (activation_readiness_gate)"; carrying version 0 →
"Invalid block version"; a block at height 2 carrying total_coinbase 0 when the schedule gives
its interval 197,732,142 → "total_coinbase below emission schedule: got 0, schedule 197732142".
Test cases · §8
11 cases · 6 valid · 5 invalid
Two transactions declaring fees 5,000,000 and 5,000,000
Loading the test widget…
The block 1's total fee
Loading the test widget…
The sum wraps in 64 bits
Loading the test widget…
A carried total fee one unit off
Loading the test widget…
Block 1 carries exactly 0
Loading the test widget…
A block at height 2 carries its interval's schedule
Loading the test widget…
A block at height 2 carrying total_coinbase 0
Loading the test widget…
A block at height 2 carrying one unit above the schedule
Loading the test widget…
The block 1 carries version 601: the newest active bundle is 601 from height 1
Loading the test widget…
The block 1 carrying version 600 is invalid
Loading the test widget…
The block 1 carrying version 0
Loading the test widget…
Defects to match. total_fee overflow is unchecked on both sides, so they agree; an
implementation must sum with wrapping i64 arithmetic.
9. The cumulative difficulty
Purpose. The fork-choice weight of a chain (24), carried as a decimal string and recomputed
by every validator.
Inputs. The previous block's cumulative_difficulty (decimal string, "0" at genesis and when
empty); the previous block's seed and height; the block's timestamp and blocksmith_public_key;
the draw set the smith was drawn from and the full active registry, both at the previous block
(20, 24); the constant divisor 1,000,000.
Output and effect. A non-negative decimal string of arbitrary length; "0" for height 0; the
validator recomputes it and requires it to be identical (string comparison), except on its own
post-rollback restore path. The increment is floor(1,000,000 × |S| / (k × |A|)) where k is the
position of the block's smith over the draw set S (rule difficulty_draw_set), |S| the
draw-set size and |A| the full active-registry size at the previous block (rule
weight_by_draw_share, the share capped at 1), and k is never better than the round the block's
timestamp falls in (rule late_stamp_priced) nor, for the previous block's blocksmith, better than
round max_priority_blocksmiths (10 on both live chains; 1 when the parameter is 0). The weight
itself and these rules are 24 and 20; this section fixes only that the field is a recomputed
decimal string outside the hash.
How to compute it. Compute k (the blocks-that-could-produce count) over the draw set as 24
and 20 specify (the draw, the last-occurrence count, the late_stamp_priced floor and the
previous blocksmith's floor at round max_priority_blocksmiths, and the first-occurrence /
hash-position fallbacks when the smith is not in the sequence); then
inc = floor(1,000,000 × |S| / (k × |A|)) with |S| = min(draw-set size, |A|); add inc to the
previous decimal string with arbitrary-width decimal addition. "0" at height 0. The previous
blocksmith is demoted, never excluded, so the chain never halts on it.
Rule activation. None in this function; the selection rules it calls (difficulty_draw_set,
weight_by_draw_share, late_stamp_priced) are at 0 on every chain (20, 24).
Rejections and errors. A carried string that differs from the recomputed one →
"Cumulative difficulty mismatch: expected X, got 'Y'"; no active nodes at the previous height →
"No active nodes for difficulty calculation". Both make the block invalid (height > 0).
Vector (computed). Block 1 produced by the first blocksmith of its round (k = 1) with the
draw set the whole registry (|S| = |A|) → inc = 1,000,000 and cumulative_difficulty
"1000000" (the block 1 of §1); four such blocks in a row carry "1000000", "2000000",
"3000000", "4000000"; a block produced at k = 2 with |S| = |A| adds 500,000, and one at
k = 1 with |S| = 3 of |A| = 11 adds 272,727; 24 derives k. Invalid input: the block 1 of
§1 carrying "1000001" → "Cumulative difficulty mismatch: expected 1000000, got '1000001'".
Test cases · §9
7 cases · 6 valid · 1 invalid
Block 1 by the first blocksmith of its round, the draw set the whole registry
Loading the test widget…
Block 2 of four such blocks in a row
Loading the test widget…
Block 3 of four such blocks in a row
Loading the test widget…
Block 4 of four such blocks in a row
Loading the test widget…
A block produced at k = 2 with |S| = |A| adds 500,000
Loading the test widget…
A block produced at k = 1 with |S| = 3 of |A| = 11 adds 272,727
Loading the test widget…
The block 1 carrying 1000001
Loading the test widget…
Defects to match. The field is outside the hash and the signature (a relay can alter it); the
recomputation check closes that on validation. The fallbacks are part of the protocol: a block
whose blocksmith is not in the sequence still gets a deterministic value. The genesis parameter
cumulative_difficulty_divisor and the compiled divisor are two copies of one number (1,000,000);
the computation uses the compiled one. An implementation must take |S|, |A| and k from the
draw set, not the registry, or it computes a different string on any block produced while a node
was suspended.
10. Size ceilings and the order of format checks
Purpose. The consensus ceilings on a block and the exact order in which a block's format is refused.
Inputs. Consensus parameters max_transactions_per_block (2,000 on both live chains) and
max_block_size_bytes (524,288 on both live chains); compiled fallbacks 500 and 88,000 when a
parameter is absent or 0.
Output and effect. A block whose ceiling count exceeds max_transactions_per_block, whose
carried payload_length exceeds max_block_size_bytes, or (rule block_size_serialized) whose
serialized size (§10.1) exceeds max_block_size_bytes, is invalid. The ceiling count is the number
of transactions, except that a SendZBCBatch or a TransferTokenBatch counts the number of its
actions (a body that does not parse counts 1) and a SubmitStorageProofBatch counts 1. The complete
validation order (format checks in bold; the others are 19, 20, 23):
- count ceiling →
"Too many transactions in block (N > M)"; byte ceiling →"Block payload_length exceeds maximum (N > M)". 1b. (ruleblock_size_serialized) serialized size (§10.1) →"BlockTooLarge: serialized N bytes over the limit M"(a block that cannot be sized →"BlockTooLarge: the block cannot be sized: <reason>"); an emptymerkle_tree→"BlockTooLarge: a main block carries no merkle_tree (N bytes attached)"("main block" in the text = main chain block); every receipt's proof within bounds →"BlockTooLarge: a receipt's proof fields are over their bound (A + B bytes)". - payload length and hash (§6).
- header: height = previous + 1 (
"Non-sequential block height");previous_block_hashequals the previous block's hash ("Invalid previous block hash"); timestamp strictly after the previous block's; not more than 7,200 s ahead of the validating node's clock ("Block timestamp too far in future", a wall-clock rule,19); the interval and window rules of19/20;version≠ 0 and ≥ the newest active bundle (§8); blocksmith key 32 bytes ("Invalid blocksmith public key size"). - the blocksmith check (
20), skipped on the self-restore path. - id (§4).
- signature (§3).
- hash (§4).
- seed (§5).
- transactions (
19): (ruleforeign_carrier_bound) no foreign carrier id spent or repeated ("ForeignCarrierReplayed",02§9); at most one transaction per account (the sender address,01§4;"Block carries two transactions from one account (<hex>, transactions i and j): one transaction per account per block"), signatures, each transaction's validity at the block height (the survival freeze included,04§6), expiry and future bound against the block's timestamp (03§5), Merkle root (§7), total_fee (§8). - receipts (
23). - cumulative difficulty (§9), height > 0, not on the self-restore path.
Apply-time checks that are also format rules: each transaction's id must be non-zero and must
equal the id derived from its hash ("Invalid transaction ID (zero)", "Transaction ID mismatch");
no duplicate transaction id in a block ("Duplicate transaction ID in block"); no transaction
already confirmed (19); the coinbase (§8).
How to compute it. As listed.
Rule activation. block_size_serialized (step 1b) and foreign_carrier_bound (step 9):
active from height 0 on every chain. The timing rules belong to 19/20.
Rejections and errors. As listed; every one makes the block invalid.
Vector (computed). Input: a block whose ceiling count is 2,001 on a chain with
max_transactions_per_block 2,000 → "Too many transactions in block (2001 > 2000)"; a block of
one SendZBCBatch of 25 payments counts 25. Input: a block carrying a 1-byte merkle_tree under
block_size_serialized → "BlockTooLarge: a main block carries no merkle_tree (1 bytes attached)".
Input: a block carrying two transactions of one sender → refused with the one-transaction-per-account
text at step 9.
Test cases · §10
5 cases · 3 valid · 2 invalid
A block whose ceiling count is 2,001
Loading the test widget…
A block of one SendZBCBatch of 25 payments counts 25
Loading the test widget…
A block carrying a 1-byte merkle_tree
Loading the test widget…
A block carrying two transactions of one sender
Loading the test widget…
Two transactions of two senders
Loading the test widget…
Defects to match. None.
10.1 The serialized block size
Purpose. The one size every node computes for a block, fixed by the block hash, so that every copy of a block measures the same.
Inputs. The block: its header fields, its transactions, the number of its published receipts.
Output and effect. BlockSerializedSize(b) (u64):
size = |unsigned header bytes (§2)| + 64 + Σ |signed transaction bytes (03 §1)| + 1,288 × |published receipts|
- The 64 is the blocksmith's signature, counted whether or not the block is signed yet (a candidate).
- Each published receipt counts a fixed 1,288 bytes = its 232 signed bytes (§6) + a 1,056-byte
proof allowance (
intermediate_hashesup to 32 × 32 = 1,024 bytes,rmr_linkedup to 32 bytes), whatever proof bytes the copy actually carries. The proof fields travel outside the block hash; counting the allowance instead of the bytes keeps the size fixed by the hash, so a relay cannot pad an honest full block's copy intoBlockTooLarge. - The bound that makes the allowance honest: under the rule a received copy whose
intermediate_hashesexceed 1,024 bytes or whosermr_linkedexceeds 32 bytes, or a main-chain copy with a non-emptymerkle_tree, is invalid (BlockTooLarge, §10 step 1b); the honest copy is unaffected (those fields are outside the hash). - A block whose header or one of whose transactions cannot be serialized (a bare 32-byte sender,
03§1) has no size and is invalid. payload_lengthkeeps its meaning (§6) and its own ceiling.
Who measures: the validator (§10 step 1b); the blocksmith, which after attaching its receipts
drops transactions from the end of its candidate until size ≤ max_block_size_bytes (the
receipts stay; a candidate whose header and receipts alone are over the limit is left with no
transactions and is then the validator's to refuse); a node receiving a full copy (one carrying
its transactions) over P2P, which sizes it before any other work and refuses one over the limit
with gRPC INVALID_ARGUMENT "relay: block over the serialized limit", charging the sender as for an
invalid block (27); an ids-only copy is sized by the validator after the transactions are fetched.
How to compute it. As the formula; every term is an unsigned 64-bit sum.
Rule activation. block_size_serialized: active from height 0 on every chain.
Rejections and errors. As in §10 step 1b.
Vector (computed). Input: the block 1 of §1 (284-byte header, no transactions, no receipts) →
348. Input: a block with the version-3 SendZBC of 02 §1 (189 signed bytes) and two published
receipts → 284 + 64 + 189 + 2 × 1,288 = 3,113 (its payload_length is 8 + 2 × 232 = 472).
Input: a block with one version-2 CreateApp with a 24-byte body and no message (169 signed bytes)
and ten receipts → 348 + 169 + 12,880 = 13,397. Invalid input, at the smallest limit a genesis
may set (max_block_size_bytes 4,096, 06 §10): a candidate holding seven such 189-byte SendZBCs
(seven senders) and two receipts measures 348 + 7 × 189 + 2 × 1,288 = 4,247 → the blocksmith drops
the last SendZBC (size 4,058, under the limit); the 4,247-byte block received as is →
"BlockTooLarge: serialized 4247 bytes over the limit 4096" (its payload_length, 7 × 8 + 2 × 232
= 520, passes the payload-length ceiling).
Test cases · §10.1
5 cases · 4 valid · 1 invalid
The block 1: a header and nothing else
Loading the test widget…
The version-3 SendZBC and two receipts
Loading the test widget…
One 169-byte CreateApp and ten receipts
Loading the test widget…
Seven 189-byte SendZBCs and two receipts at the smallest limit, 4,096
Loading the test widget…
The blocksmith drops the last SendZBC: 4,058 bytes
Loading the test widget…
Defects to match. None.
11. The wire form
Purpose. How a block travels between nodes (27 specifies the procedures).
Inputs. The block; the transport is gRPC with protobuf messages (27).
Output and effect. The Block message (proto3, package service; field names and numbers
are the wire contract):
| # | Field | Proto type | Carries |
|---|---|---|---|
| 1 | ID |
int64 | §4 (0 allowed on receipt: derived from the hash) |
| 2 | BlockHash |
bytes | §4 |
| 3 | PreviousBlockHash |
bytes | §1 |
| 4 | Height |
uint32 | |
| 5 | Timestamp |
int64 | |
| 6 | BlockSeed |
bytes | §5 |
| 7 | BlockSignature |
bytes | §3 |
| 8 | CumulativeDifficulty |
string | §9 (omitted when empty on broadcast) |
| 9 | BlocksmithPublicKey |
bytes | |
| 10 | TotalAmount |
int64 | |
| 11 | TotalFee |
int64 | |
| 12 | TotalCoinBase |
int64 | |
| 13 | Version |
uint32 | |
| 14 | PayloadLength |
uint32 | |
| 15 | PayloadHash |
bytes | |
| 16 | MerkleRoot |
bytes | §7 |
| 17 | MerkleTree |
bytes | empty on the main chain (a main chain block carrying one is invalid, §10.1) |
| 18 | ReferenceBlockHeight |
uint32 | sent on the sync form; on broadcast only for spine blocks |
| 19 | Transactions |
repeated Transaction |
full transactions (03 §10; TransactionBytes is the authoritative field) — sync form only |
| 20 | PublishedReceipts |
repeated PublishedReceipt |
always |
| 21 | SpinePublicKeys |
repeated SpinePublicKey |
spine only (25) |
| 22 | SpineBlockManifests |
repeated SpineBlockManifest |
spine only (25) |
| 23 | TransactionIDs |
repeated int64 | the broadcast form: the ids of the block's transactions in order, bodies omitted |
| 24 | BlockSeedProof |
bytes | §5: the 80-byte ECVRF proof; empty only at genesis; carried on both the broadcast and the sync form |
| 25 | ReferenceCommitment |
bytes | spine blocks only (25): LE32(reference height) ‖ referenced main chain block hash ‖ its cumulative difficulty (decimal ASCII); empty on the main chain |
| 26 | SpineRefusals |
repeated SpineRefusal |
spine blocks only (25): the signed non-signing statements a spine block carries; empty on the main chain |
SpineRefusal = uint32 spine_height (1), bytes refused_block_hash (2), bytes node_public_key
(3), bytes signature (4). PublishedReceipt = Receipt Receipt (1), bytes IntermediateHashes (2), uint32 BlockHeight
(3), uint32 PublishedIndex (4), bytes RMRLinked (5), uint32 RMRLinkedIndex (6); Receipt =
SenderPublicKey (1), RecipientPublicKey (2), uint32 DatumType (3), DatumHash (4),
uint32 ReferenceBlockHeight (5), ReferenceBlockHash (6), RMR (7), RecipientSignature (8).
SpinePublicKey = NodePublicKey (1), int64 NodeID (2), uint32 PublicKeyAction (3),
uint32 MainBlockHeight (4), uint32 Height (5). SpineBlockManifest = int64 ID (1),
FullFileHash (2), FileChunkHashes (3), uint32 ManifestReferenceHeight (4),
uint32 ManifestSpineBlockHeight (5), uint32 ChainType (6), int64 ExpirationTimestamp (7),
ChainGenesisHash (8).
Two forms are sent. Broadcast (SendBlockRequest: Block (1), int32 ChainType (2),
bytes SenderPublicKey (3), uint32 SenderChainHeight (4), string SenderCumulativeDifficulty
(5), bytes SenderSignature (6), the receipt-request signature of 02 §11): the header fields,
the receipts and TransactionIDs, no Transactions; the receiver fills the bodies from its
pool and asks for the missing ones (27). Sync (BlocksData: repeated Block NextBlocks) and
the candidate exchange (BlockCandidateMessage: Block block (1), bytes creator_public_key (2),
int32 priority_position (3), int64 received_at (4)): full Transactions, every field set.
A receiver of SendBlock reads the header fields verbatim, derives id when it is 0, and refuses
before validation (gRPC INVALID_ARGUMENT) a message with more than max_transactions_per_block
transactions or transaction ids ("Too many transactions in block", "Too many transaction IDs in block"; these caps count transactions, not batch actions), a PayloadLength above
max_block_size_bytes ("Block payload exceeds max size"), a full copy over the serialized limit
(§10.1), or more than the larger of 500 and max_transactions_per_block transactions or
transaction ids (2,000 on both chains) or more than 65,536 receipts, spine keys, manifests or spine
refusals (the transport caps of 27 §2: decoded as an empty block that then fails validation). A
node decoding a block it fetched (sync, fork download, candidates, a promised spine block) applies
the same caps and refuses the fetched block ("GoProtoToBlock: oversized repeated field (anti-amplification)").
How to compute it. Standard protobuf encoding; the bytes fields are the raw 32/64/80-byte
values of §1.
Rule activation. The serialized-size refusal: rule block_size_serialized (§10.1).
Rejections and errors. As listed (gRPC INVALID_ARGUMENT).
Vector (computed). Input: a SendBlockRequest whose Block.TransactionIDs holds 2,001 ids on a
chain with max_transactions_per_block 2,000 → gRPC INVALID_ARGUMENT "Too many transaction IDs
in block". The field values of an accepted block are those of §2–§9.
Test cases · §11
1 case · 1 invalid · 1 reference
A SendBlock carrying 2,001 transaction ids on a chain of 2,000
A stated value: there is nothing to compute. The statement is a refusal: the exact text a compatible node answers.
- refusal
Too many transaction IDs in block- grpc
INVALID_ARGUMENT
Defects to match. The broadcast fill omits MerkleTree and ReferenceBlockHeight for a main
block and omits CumulativeDifficulty when empty; the sync fill sends them all. A receiver must not
depend on their presence. A block received without field 24 hashes over 268 bytes and its signature
fails, which is correct: such a block is invalid.
12. The API form
Purpose. How a node and the archival present a block to clients.
Inputs. GET /api/v1/blocks/height/<h>, GET /api/v1/blocks/hash/<hex>,
GET /api/v1/blocks/latest on a node (31); the archival's GET /api/v1/blocks/<h> and its
/blocks/latest.
Output and effect. The node answers one JSON object: height, version, timestamp,
previous_block_hash, block_seed, block_seed_proof (lower-case hex, empty string at genesis),
block_signature, cumulative_difficulty (string), blocksmith_public_key, total_amount,
total_fee, total_coinbase, block_hash, merkle_root, merkle_tree,
reference_block_height, transaction_count, transactions (the transaction hashes in block
order); all byte fields as lower-case hex. A block this node has pruned may be served from the
snapshot the decentralised storage keeps for its height (the archive, 11, 26): the same object
followed by "source":"snapshot", "snapshot_reference_height" and "spine_height"; rebuilding a
snapshot that is not already rebuilt is done only for this node's operator (loopback with nothing
relayed, or a request signed with this node's key), others get 403 (31). The archival answers a
shorter object with upper-case hex: block_hash, block_seed, block_seed_proof,
blocksmith_public_key, hash, height, payload_length, previous_block_hash,
previous_hash, release, timestamp, total_coinbase, total_fee, transaction_count,
tx_count, version (hash/block_hash, previous_hash/previous_block_hash and
tx_count/transaction_count are two names for the same values).
How to compute it. Serialise the fields of §1.
Rule activation. None.
Rejections and errors. 404 for an unknown height or hash (31).
Vector (computed, the block 1 of §1 as a node serves it). GET /api/v1/blocks/height/1 →
{"height":1,"version":601,"timestamp":1793509042,"previous_block_hash":"3a2897e7c5ad6143429bab33a92d14d11ffd6fc281f2b62a6fd6b49c183b863d","block_seed":"0aaaaa12…85b3","block_seed_proof":"542529a7…1d0b","block_signature":"6b9a7c6a…f50c","cumulative_difficulty":"1000000","blocksmith_public_key":"8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c","total_amount":0,"total_fee":0,"total_coinbase":0,"block_hash":"c056a43b22436827a0b979d4725c579e6768fba0bab7c8941e69142fcf29f6fb","merkle_root":"0000000000000000000000000000000000000000000000000000000000000000","merkle_tree":"","reference_block_height":0,"transaction_count":0,"transactions":[]}
(the elided values are those of §2–§5). The archival serves the same block as
{"block_hash":"C056A43B…F6FB","block_seed":"0AAAAA12…85B3","block_seed_proof":"542529A7…1D0B","blocksmith_public_key":"8A88E3DD…6F5C","hash":"C056A43B…F6FB","height":1,"payload_length":0,"previous_block_hash":"3A2897E7…863D","previous_hash":"3A2897E7…863D","release":"0.6.1","timestamp":1793509042,"total_coinbase":0,"total_fee":0,"transaction_count":0,"tx_count":0,"version":601}
(upper-case hex; release is the archival's own version text).
Test cases · §12
2 cases · 2 valid · 2 reference
A node's JSON for the block 1
GET /api/v1/blocks/height/1.
A stated value: there is nothing to compute. A compatible node shows the same value.
- height
1- version
601- timestamp
1793509042- previous_block_hash
3a2897e7c5ad6143429bab33a92d14d11ffd6fc281f2b62a6fd6b49c183b863d- block_seed
0aaaaa1285e87f89b1bddb73cebe33ee2966bf8d3291c4032bfa0445fa8aa242f50ec37f4d2315be1345bbbb2ed60ee130002e92a42a10c54e00018f69fd85b3- block_seed_proof
542529a7c6e4557c0b133b605bfeda1850e8a6fcee80fa47fd892482afa6f4c8cd092d802ef89d6748dd49437f9a3b385c4869b410f02c864a3dc81b3d2d766796fc724a3dca71fe10e5c0b80cfa1d0b- block_signature
6b9a7c6a325346f802dc42d4433792fa3f7aaaf20400498d84747b92de35d1ed5edc621482a2b6cf75e9f00866137d8d6fbe96b2107f996d5b6c55abe679f50c- cumulative_difficulty
1000000- blocksmith_public_key
8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c- total_amount
0- total_fee
0- total_coinbase
0- block_hash
c056a43b22436827a0b979d4725c579e6768fba0bab7c8941e69142fcf29f6fb- merkle_root
0000000000000000000000000000000000000000000000000000000000000000- merkle_tree
- reference_block_height
0- transaction_count
0
The archival's JSON for the block 1
Upper-case hex; release is the archival's own version text.
A stated value: there is nothing to compute. A compatible node shows the same value.
- block_hash
C056A43B22436827A0B979D4725C579E6768FBA0BAB7C8941E69142FCF29F6FB- hash
C056A43B22436827A0B979D4725C579E6768FBA0BAB7C8941E69142FCF29F6FB- height
1- payload_length
0- previous_block_hash
3A2897E7C5AD6143429BAB33A92D14D11FFD6FC281F2B62A6FD6B49C183B863D- previous_hash
3A2897E7C5AD6143429BAB33A92D14D11FFD6FC281F2B62A6FD6B49C183B863D- release
0.6.1- timestamp
1793509042- total_coinbase
0- total_fee
0- transaction_count
0- tx_count
0- version
601
Defects to match. None (presentation).
13. What the hash and the signature cover
| Field | Signed (284 bytes) | Hashed (348 bytes) | Validated by recomputation |
|---|---|---|---|
| version, timestamp, total_amount, total_fee, total_coinbase, payload_length, payload_hash, blocksmith_public_key, block_seed, previous_block_hash, block_seed_proof | yes | yes | total_fee (sum), total_coinbase (= schedule), payload (§6), seed and proof (§5), previous hash (link), version ≠ 0 and ≥ the active bundle |
| block_signature | — | yes | §3 |
| block_hash, id | — | — | §4 |
| height | no | no | previous + 1 |
| cumulative_difficulty | no | no | §9 (string equality) |
| merkle_root | no | no | §7, only when non-empty; the derived root is stored |
| merkle_tree | no | no | must be empty on the main chain (§10.1) |
| reference_block_height, transaction_ids | no | no | not checked on the main chain |
| transactions, published_receipts | through payload_hash | through payload_hash | 19, 23; the receipts' proof fields bounded (§10.1) |
An implementation at level L1 must implement §2–§10 exactly, including the 80-byte seed proof
inside the signed and hashed bytes, the ECVRF seed (01 §8) and the serialized size; L2 produces
them in the blocksmith's order of §1 with its bundle id as the version, the exact coinbase schedule
and the size trim; L3 serves §12.
A question about this chapter, or a statement that does not match the network? Discuss on zoobc.pro.