On this page
  1. §0 The area in one paragraph
  2. 1. The header fields
  3. 2. The header bytes
  4. 3. The block signature
  5. 4. The block hash and the block id
  6. 5. The block seed
  7. 6. The payload hash and the payload length
  8. 7. The transaction Merkle root
  9. 8. The totals and the constant fields
  10. 9. The cumulative difficulty
  11. 10. Size ceilings and the order of format checks
  12. 10.1 The serialized block size
  13. 11. The wire form
  14. 12. The API form
  15. 13. What the hash and the signature cover

05 — The block format

Edition 0.6.1 · verified against the reference implementation, version 0.6.1

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 §105-1-block1-fieldsvalidreference

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 105-2-block1-bytesvalid

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.

Inputs. The 284 unsigned bytes of §2; the blocksmith's Ed25519 key pair (the node key, 02 §3).

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)05-3-block1-signvalid

Loading the test widget…

The block 1's signature verifies over its 284 unsigned bytes05-3-block1-signaturevalid

Loading the test widget…

The same signature over the first 204 bytes only does not verify05-3-signature-204valid

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 bytes05-4-block1-hashvalid

Loading the test widget…

A block id read from the hash05-4-id-derivedvalid

Loading the test widget…

The block 1 carrying id 105-4-id-mismatchinvalid

Loading the test widget…

A hash whose first 8 bytes are zero gives id 005-4-id-zeroinvalid

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 bytes05-5-block1-seedvalid

Loading the test widget…

The block 1 carried with an empty proof05-5-no-proofinvalid

Loading the test widget…

The block 1 carried with the seed's first byte changed to 0b05-5-wrong-seedinvalid

Loading the test widget…

A 32-byte seed05-5-short-seedinvalid

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 when payload_data is 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 (the body_length field 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 transaction05-6-one-txvalid

Loading the test widget…

The payload of one transaction and one receipt05-6-tx-receiptvalid

Loading the test widget…

The same receipt with an empty rmr05-6-empty-rmrvalid

Loading the test widget…

An empty block05-6-emptyvalid

Loading the test widget…

One 24-byte-body transaction and ten receipts of 232 bytes05-6-ten-receiptsvalid

Loading the test widget…

The one-transaction payload carrying payload_length 905-6-length-mismatchinvalid

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 hash05-7-onevalid

Loading the test widget…

Two transactions: SHA3-256 of the two hashes05-7-twovalid

Loading the test widget…

Five transactions: the fifth paired with itself at levels 0 and 105-7-fivevalid

Loading the test widget…

A block without transactions (the block 1)05-7-nonevalid

Loading the test widget…

The two-transaction block carrying the root 00…0105-7-wronginvalid

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,00005-8-fee-twovalid

Loading the test widget…

The block 1's total fee05-8-fee-emptyvalid

Loading the test widget…

The sum wraps in 64 bits05-8-fee-wrapsvalid

Loading the test widget…

A carried total fee one unit off05-8-fee-mismatchinvalid

Loading the test widget…

Block 1 carries exactly 005-8-coinbase-1valid

Loading the test widget…

A block at height 2 carries its interval's schedule05-8-coinbase-2valid

Loading the test widget…

A block at height 2 carrying total_coinbase 005-8-coinbase-2-zeroinvalid

Loading the test widget…

A block at height 2 carrying one unit above the schedule05-8-coinbase-overinvalid

Loading the test widget…

The block 1 carries version 601: the newest active bundle is 601 from height 105-8-version-601valid

Loading the test widget…

The block 1 carrying version 600 is invalid05-8-version-600invalid

Loading the test widget…

The block 1 carrying version 005-8-version-0invalid

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 registry05-9-height-1valid

Loading the test widget…

Block 2 of four such blocks in a row05-9-height-2valid

Loading the test widget…

Block 3 of four such blocks in a row05-9-height-3valid

Loading the test widget…

Block 4 of four such blocks in a row05-9-height-4valid

Loading the test widget…

A block produced at k = 2 with |S| = |A| adds 500,00005-9-k-2valid

Loading the test widget…

A block produced at k = 1 with |S| = 3 of |A| = 11 adds 272,72705-9-s-3valid

Loading the test widget…

The block 1 carrying 100000105-9-mismatchinvalid

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

  1. count ceiling → "Too many transactions in block (N > M)"; byte ceiling → "Block payload_length exceeds maximum (N > M)". 1b. (rule block_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 empty merkle_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)".
  2. payload length and hash (§6).
  3. header: height = previous + 1 ("Non-sequential block height"); previous_block_hash equals 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 of 19/20; version ≠ 0 and ≥ the newest active bundle (§8); blocksmith key 32 bytes ("Invalid blocksmith public key size").
  4. the blocksmith check (20), skipped on the self-restore path.
  5. id (§4).
  6. signature (§3).
  7. hash (§4).
  8. seed (§5).
  9. transactions (19): (rule foreign_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).
  10. receipts (23).
  11. 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,00105-10-count-2001invalid

Loading the test widget…

A block of one SendZBCBatch of 25 payments counts 2505-10-batch-25valid

Loading the test widget…

A block carrying a 1-byte merkle_tree05-10-merkle-treevalid

Loading the test widget…

A block carrying two transactions of one sender05-10-two-from-oneinvalid

Loading the test widget…

Two transactions of two senders05-10-two-sendersvalid

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_hashes up to 32 × 32 = 1,024 bytes, rmr_linked up 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 into BlockTooLarge.
  • The bound that makes the allowance honest: under the rule a received copy whose intermediate_hashes exceed 1,024 bytes or whose rmr_linked exceeds 32 bytes, or a main-chain copy with a non-empty merkle_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_length keeps 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 else05-10_1-block1valid

Loading the test widget…

The version-3 SendZBC and two receipts05-10_1-tx-2-receiptsvalid

Loading the test widget…

One 169-byte CreateApp and ten receipts05-10_1-createapp-10-receiptsvalid

Loading the test widget…

Seven 189-byte SendZBCs and two receipts at the smallest limit, 4,09605-10_1-overinvalid

Loading the test widget…

The blocksmith drops the last SendZBC: 4,058 bytes05-10_1-trimmedvalid

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,00005-11-too-many-idsinvalidreference

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 105-12-nodevalidreference

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 105-12-archivalvalidreference

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.