On this page
  1. §0 The area in one paragraph
  2. §1 The blocksmith's one block per parent
  3. §2 The EquivocationReport transaction (type 60)
  4. §3 Validity of an EquivocationReport
  5. §4 The charge (one miss, once per blocksmith and height)
  6. §5 The resume exemption (equivocation_resume_exempt)
  7. §6 The peer-side verdict and ban
  8. §7 The SpineEquivocationReport (type 62)
  9. §8 Consensus and local; summary of defects

35 — Equivocation: the blocksmith's one block per parent, the EquivocationReport, the SpineEquivocationReport, the charge

Edition 0.6.1 · verified against the reference implementation, version 0.6.1

Out of scope the block header byte layout (05) and the block signature (02); how a liveness miss suspends and expels a node (36); the peer blacklist and fork choice that keep both blocks (27, 24); the spine signature, the signing commitment and the non-signing statement themselves (25, 27)

§0 The area in one paragraph

A blocksmith equivocates when it signs two different blocks over the same parent — the same height on two branches. The protocol answers it in three places. First, an honest blocksmith never does it: it remembers, per parent, the block it signed (in memory and in a node-local table that survives a restart, block bytes included) and hands back the same bytes rather than sign a second (§1). Second, anyone who sees two validly-signed headers by one registered blocksmith over one parent builds an EquivocationReport (transaction type 60, a fee-free duty) carrying both headers and both signatures (§2), the chain checks it (§3) and, once per blocksmith per height, charges the blocksmith one liveness miss and writes an equivocation_charge row (§4): the blocksmith is then missing — no income, its score falling — until its next own block, and four consecutive misses suspend it (36). A double-sign is not "slashable": no stake is taken for it. Third, the node that relays the two blocks records the blocksmith as a proven liar and disconnects it, but does not drop either block — first-seen differs per node, so dropping would fork the honest ones; fork choice (24, tie-by-hash) picks the survivor and the report is the remedy (§6, 27). One narrow exception keeps a stalled chain recoverable: a pair of headers that straddles the recovery limit from the parent is a resume, not a lie (§5). A spine signer that votes both ways on one spine block candidate — a spine signature on it and a non-signing statement on the same candidate at the same spine height — is charged the same way through a SpineEquivocationReport (transaction type 62, §7); signing two different candidates at one spine height is not reportable, because the non-signing round frees a signer to sign another. None of this is in a snapshot except the two charge tables (consensus state, 07); the blocksmith's own memory, the wire ban and a node's record of its own non-signing statements are node-local.

§1 The blocksmith's one block per parent

Purpose. Stop an honest node from ever signing two different blocks over one parent, which equivocation_miss would charge it for and every relaying peer would record as a lie.

Inputs. The block the blocksmith is about to sign; its parent block (hash and timestamp); the node-local producer_signed_parent table (the blocksmith's record of the parents it signed over); max_recovery_interval_seconds (= MAX_RECOVERY_INTERVAL_SECONDS 3,600 when the chain has no row, 32 §12).

Output and effect. The guard holds, per parent_hash, two slots: the block this node signed within the recovery limit of the parent and the one it signed past it. A block's side is decided by its own timestamp stamp: past when recovery_limit > 0 and stamp − parent.timestamp > recovery_limit (the wall clock past the limit is not enough; a block stamped at the limit itself is within). Before signing, Decide(parent, stamp, limit): no block on that side → Sign; a block on that side held in memory → Resend (the same bytes; re-sending proves nothing); a side known to be signed but with no block to hand back → Refuse. So over one parent a blocksmith signs at most one block within the limit and one fresh resume block past it (the pair straddles the limit and is not charged, §5), and re-sends the resume block at every later draw. After signing, Remember(block, position, past) records it. The memory is pruned below tip − 720.

Persistence. A node-local table (not consensus state, never in a snapshot) keeps one row per parent: parent_hash (32 bytes, the key), height (integer), within_limit and past_limit (0/1 flags: the sides signed), within_block and past_block (bytes: the signed block of that side in its wire form, may be empty), within_position and past_position (integer: its priority position). Writing a parent that already has a row keeps the larger of each flag and of height, and, per side, the signed block in its wire form and its priority position (a non-empty new block replaces the stored one; an empty one keeps it). At start each flagged side is loaded: when its stored bytes decode to a block over that parent with a hash and a signature, the block is remembered (the blocksmith re-sends it at the next draw); otherwise the side is marked signed with no block (the blocksmith refuses a second signature on that side), so that draw produces nothing from this node. The table is pruned below tip − 720. Node-local: a node restored from a snapshot or a fresh database has no memory of parents it signed before and relies on the chain already holding its blocks. A re-sent block that reaches a peer after its height is already taken is bounced as a duplicate or refused by validation; the blocksmith's only consequence is the missed turn the skip rule already charges (36 §3), and the peer takes no strike for it (28).

How to compute it. side = past when limit > 0 and stamp − parent.timestamp > limit, else within; then: the side's slot empty → sign; the slot holds a block → re-send it; the slot is marked signed without a block → refuse. Check, sign, record in memory and record in the table happen as one step.

Rule activation. No rule of its own: this is the honest blocksmith's discipline. It exists because equivocation_miss (§3) is on; the resume exception follows halt_recovery_param (the recovery limit, 19/20) and equivocation_resume_exempt (§5), active from height 0 on every chain.

Rejections and errors. None at the chain layer; the blocksmith simply does not emit a second block (or re-emits the first).

Vector. computed: a registered node drawn twice over parent P (a round wrap with 2 live of 4, or a rollback to P then replay) signs once; a second draw stamped within 3,600 s of P.timestamp returns the first block's bytes; the first draw stamped more than 3,600 s after P.timestamp signs a fresh block (the resume); every later draw past the limit returns the resume block's bytes; after a restart the stored bytes are handed back the same way.

Test cases · §1

4 cases · 4 valid · 1 reference

One block per parent: re-send within the limit, one resume past it, the same after a restart35-1-guardvalid

Loading the test widget…

A block stamped at the limit itself is within it35-1-guard-at-limitvalid

Loading the test widget…

After a restart with unreadable stored bytes the signed side refuses35-1-guard-lost-bytesvalid

Loading the test widget…

The guard's stated values35-1-guard-valuesvalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

default_recovery_limit_seconds
3600
pruned_below
tip - 720
slots_per_parent
2 (within the limit, past it)

Defects to match. None.

§2 The EquivocationReport transaction (type 60)

Purpose. The transaction that hands the chain the proof: two different signed headers by one blocksmith over one parent.

Inputs. Two signed-header byte strings (05: 204 bytes, or 284 with the 80-byte VRF proof) and their 64-byte signatures; the key of the node that sends the report.

Output and effect. A transaction of type 60 (EquivocationReport), version 1, survival 0, fee 0 (a fee-free duty, 04), sender 00000000 ‖ node_public_key (the typed node-key account of the node that sends the report; any other sender form names no node). Its body is the two headers and signatures:

offset length field encoding
0 4 len1 = length of header 1 uint32 LE; 204 or 284
4 len1 header1 the signed header bytes of 05
4 + len1 64 signature1 Ed25519 over header 1 by the blocksmith
68 + len1 4 len2 = length of header 2 uint32 LE
72 + len1 len2 header2
72 + len1 + len2 64 signature2

No trailing bytes. Total = 8 + len1 + len2 + 128: 704 bytes for two 284-byte (VRF) headers, 544 for two 204-byte headers. Any node that verifies both headers (the wire check of §6, or a replay) builds it; it is relayed and mined like any duty.

How to compute it. For each header in order: len (uint32 LE) ‖ header ‖ signature. The transaction envelope is 03; the signing digest is 02.

Rule activation. Type 60 is gated by equivocation_miss (29), active from height 0 on every chain.

Rejections and errors. "EquivocationReport body too short", "EquivocationReport header length out of range" (a len of 0, > 4,096, or overrunning the body), "EquivocationReport: trailing bytes" (the parse); the validity of §3.

Vector. computed (script kept with the edition's vectors).

  • INPUT: blocksmith key from the Ed25519 seed e40dfcf9bcaf9468c0d0cc6cd42d5f9511c76388cbc0a7b3be65ba5f2239388a (public key 6fbbeb57e9c7948cbd056e62f80c6b840b9432fc0bd2f9edf88ae9a1e0c532f2); parent hash 041ac95d64c57201f1a100e1e2323ea09174698b7188e6ac8720e267657dfed6, parent timestamp 1,793,513,527. Two 204-byte headers, every byte 0 except: bytes 0–3 59020000 (version 601), bytes 4–11 the timestamp as int64 LE (header 1: 1,793,513,542 = 46d8e66a00000000; header 2: 1,793,513,557 = 55d8e66a00000000), bytes 76–107 the public key, bytes 172–203 the parent hash. Each signed with plain Ed25519 by the blocksmith key.
  • EXPECTED OUTPUT: signature1 = 19bc735e5d2fb10e2d534d9cfd7ca0ce4cb30df906348ed7637c09396968e9e3118ec088191b14f55d41a5b35ea7d018af3f4fcebbd2702370a44a98265f350b; signature2 = d49b03ec2dc672f2e99bf06e1859ee326d8d6c3d4635435063f03344ca1e5675484aab0eb99e4569f4189afad2e3246efdfaa886164908d8fb9fcea9d7f4c601; the body is 544 bytes, beginning cc000000 59020000 46d8e66a00000000, signature1 at offset 208, len2 (cc000000) at offset 272, signature2 at offset 480; SHA3-256 of the body = 8ebeb14bb163dd1dbc0c45c84e1e084a29f434c5bc168489bb2192db79795966.
  • INVALID INPUT: the same body cut to 543 bytes → EquivocationReport header length out of range (len2 + 64 overruns the body). The body with one byte 00 appended (545 bytes) → EquivocationReport: trailing bytes.

Test cases · §2

8 cases · 3 valid · 5 invalid · 1 reference

Two headers by one blocksmith over one parent: signatures, the 544-byte body and its hash35-2-bodyvalid

Loading the test widget…

The body reads back into two 204-byte headers35-2-parsevalid

Loading the test widget…

The body cut to 543 bytes35-2-cutinvalid

Loading the test widget…

The body with one byte appended35-2-trailinginvalid

Loading the test widget…

A body of three bytes35-2-too-shortinvalid

Loading the test widget…

A header length of 035-2-zero-lengthinvalid

Loading the test widget…

A header length of 4,09735-2-over-4096invalid

Loading the test widget…

The stated body sizes35-2-sizesvalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

two_204_byte_headers
544
two_284_byte_headers
704
type
60
version
1
fee
0
survival
0

Defects to match. A header length is bounded at 4,096 by the parser but must be exactly 204 or 284 to pass §3; a report of two headers that are byte-identical is refused (§3), so re-sending one block is never evidence.

§3 Validity of an EquivocationReport

Purpose. What the chain checks before it charges a blocksmith.

Inputs. The report; the block height h it is judged at (admission: tip + 1); the main chain; the node registry as of h − 1; the equivocation_charge table as of h − 1.

Output and effect. Accept (the charge of §4 follows) or a validation error that keeps the report out of a block (and, mined anyway, makes the block invalid). In order:

  1. equivocation_miss active at h (else "EquivocationReport needs rule equivocation_miss (active from height …)").
  2. fee == 0, judged by the general check of a node duty's fee, which runs before the report's own checks (else "Transaction fee must be exactly 0: a node duty declares a fee of exactly zero (this one declares F)", F the declared fee).
  3. The body parses (§2) and each header is a valid signed-header size, 204 or 284, else "EquivocationReport: each header must be the signed header bytes (204, or 284 with the seed proof)".
  4. header1 ≠ header2 ("EquivocationReport: the two headers are the same block").
  5. The blocksmith key — bytes 76…107 of each header — is equal in both ("EquivocationReport: the two headers name different producers").
  6. The parent hash — bytes 172…203 of each header — is equal in both ("EquivocationReport: the two headers build on different parents (not one height)").
  7. Each signature verifies as Ed25519 over its header bytes under the blocksmith key ("EquivocationReport: a header signature does not verify under the producer key").
  8. The parent hash is a block in this chain with is_main_chain = 1; parent_height = its height; equivocated_height = parent_height + 1 (else "EquivocationReport: the parent block is not in this chain").
  9. The pair does not straddle the recovery limit (§5), else "EquivocationReport: the two headers straddle the recovery limit from their parent (a resume block; rule equivocation_resume_exempt)".
  10. Evidence window: h ≤ equivocated_height + EQUIVOCATION_EVIDENCE_MAX_AGE_BLOCKS (720), else "EquivocationReport: evidence older than 720 blocks".
  11. The blocksmith key is a registered node (status ≠ Deleted) as of h − 1 ("EquivocationReport: the producer key is no registered node").
  12. The sender — the node key of its typed account (36 bytes, type 0 → its last 32 bytes) — is a registered node as of h − 1 ("EquivocationReport must be sent by a registered node's key").
  13. The pair (blocksmith node_id, equivocated_height) has no equivocation_charge row with height ≤ h − 1 ("EquivocationReport: this producer is already charged for that height").

A read of the parent, the straddle or the charge table that fails is an error on this node (the report is not judged), never "not exempt" or "not yet charged". The evidence window guarantees every node holds the parent: an admissible report's parent is at most 721 blocks below h, the prune keeps at least 1,440 blocks, and a snapshot carries the blocks from S − 720 (26 §2), so steps 8 and 9 read the same parent on every node.

How to compute it. As the list; steps 5, 6 read the fixed header offsets of §2, step 7 uses 02's verify, steps 8–13 read the database.

Rule activation. equivocation_miss and equivocation_resume_exempt (step 9), active from height 0 on every chain.

Rejections and errors. The thirteen strings above (in them, "producer" means the blocksmith).

Vector. computed.

  • INPUT: the §2 body, fee 0, sent by a registered node's typed account; the parent at height 300 of this chain; the blocksmith key registered; judged at h = 331; no charge row. EXPECTED OUTPUT: accepted, equivocated_height = 301.
  • INVALID INPUT: the same body with byte 4 of header2 (offset 276 of the body) changed from 55 to 56 → EquivocationReport: a header signature does not verify under the producer key.
  • INVALID INPUT: header2 replaced by header1 and signature2 by signature1 → EquivocationReport: the two headers are the same block.
  • INVALID INPUT: the valid body judged at h = 1,022 → EquivocationReport: evidence older than 720 blocks (1,022 > 301 + 720).
  • INVALID INPUT: the valid body with fee 1 → Transaction fee must be exactly 0: a node duty declares a fee of exactly zero (this one declares 1).

Test cases · §3

15 cases · 3 valid · 12 invalid

A valid report judged at height 33135-3-acceptedvalid

Loading the test widget…

Header 2 changed after signing (body offset 276 from 55 to 56)35-3-bad-signatureinvalid

Loading the test widget…

Header 2 replaced by header 135-3-same-blockinvalid

Loading the test widget…

The valid report judged at height 1,02235-3-too-oldinvalid

Loading the test widget…

The valid report judged at height 1,021, the last height of the window35-3-last-heightvalid

Loading the test widget…

The valid report with fee 135-3-feeinvalid

Loading the test widget…

A header of 203 bytes35-3-short-headerinvalid

Loading the test widget…

The second header names another blocksmith key35-3-two-blocksmithsinvalid

Loading the test widget…

The second header builds on another parent35-3-two-parentsinvalid

Loading the test widget…

The parent is not a block of this chain35-3-unknown-parentinvalid

Loading the test widget…

Two headers on both sides of the recovery limit (15 s and 3,601 s after the parent)35-3-straddleinvalid

Loading the test widget…

The blocksmith key is no registered node35-3-blocksmith-unregisteredinvalid

Loading the test widget…

The sender is no registered node35-3-reporter-unregisteredinvalid

Loading the test widget…

The blocksmith is already charged for height 30135-3-chargedinvalid

Loading the test widget…

A charge row written at the judged height itself does not count yet35-3-charged-latervalid

Loading the test widget…

Defects to match. None.

§4 The charge (one miss, once per blocksmith and height)

Purpose. The effect a valid report has on the blocksmith.

Inputs. The valid report; the block height H it is applied at; the node registry; the equivocation_charge table; the liveness state (36).

Output and effect. With equivocation_miss active at H: re-derive the blocksmith key and parent; a parent not in the main chain → no-op; equivocated_height = parent_height + 1; a resume-exempt pair (§5) → no charge (no-op); a blocksmith key that is no longer a node → no-op. Otherwise node_id = the blocksmith's registry id; if an equivocation_charge row for (node_id, equivocated_height) exists with height ≤ H → no-op (the charge is once per blocksmith per height, so several reports of the same equivocation charge it once). Else write one row to equivocation_charge(node_id, equivocated_height, reporter = the report's sender account, height = H) (at most one row per (node_id, equivocated_height); a second write for the same pair is ignored; rows above a pop-off target are deleted). Then, when liveness_miss_rule is accumulating at H (29, warm-up), one liveness miss is charged against the blocksmith, consequential once liveness_miss_rule is active: the miss puts the blocksmith in the score road's missing state (misses > 0; a node not yet missing starts its missing stretch at the unit clock), so it earns nothing and loses 5 points per unit, prorated per block, until its next own block clears it; the fourth consecutive miss suspends it (36). No balance moves; no ledger row names an account. Every read that fails (the parent, the straddle, the registry, the charge table, the liveness row, the unit clock) fails the block on this node.

Data model. equivocation_charge: node_id (64-bit signed integer), equivocated_height (32-bit), reporter (bytes: the report's sender account, 36 bytes), height (32-bit: the block that wrote it); (node_id, equivocated_height) is the key. "Charged as of x" = a row for the pair with height ≤ x exists. A pop-off to target deletes every row with height > target. It is a snapshot state table (26, 07).

How to compute it. As stated; the charge row and the miss are the whole effect.

Rule activation. equivocation_miss, liveness_miss_rule, equivocation_resume_exempt, all active from height 0 on every chain.

Rejections and errors. No guard refuses the block; every guard is a silent no-op (already charged, resume-exempt, blocksmith not found, liveness_miss_rule not yet accumulating); a database fault fails the block.

Vector. computed: a first valid report of blocksmith N equivocating at height 301 writes (N, 301, <the report's sender>, H) and charges N one miss; a second report of the same (N, 301) is a no-op; a report of N equivocating at a different height 305 charges again.

Test cases · §4

2 cases · 2 valid · 1 reference

A first report charges, a second of the same height is a no-op, another height charges again35-4-oncevalid

Loading the test widget…

The equivocation_charge row35-4-tablevalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

key
(node_id, equivocated_height)
columns
node_id int64, equivocated_height uint32, reporter 36 bytes, height uint32
pop_off
rows with height > target are deleted
stake_taken
none

Defects to match. The charge is keyed on (node_id, equivocated_height), so a blocksmith that equivocates at many heights is charged once per height (not once ever); a second row for a pair is never written, so the sender of a duplicate report cannot be paid or penalised for it.

§5 The resume exemption (equivocation_resume_exempt)

Purpose. Keep a halted chain recoverable: a blocksmith whose block over a parent was never selected may sign a fresh block over that parent once the gap is long enough, without being convicted of equivocation.

Inputs. The report's two headers; their parent's timestamp from this chain; max_recovery_interval_seconds (3,600 when no row); the rule height.

Output and effect. The pair is exempt when equivocation_resume_exempt is active at h, the body parses, both headers are valid sizes, the parent is in this chain's main chain, and the two header timestamps straddle the recovery limit from the parent: (t1 − parent_ts > limit) ≠ (t2 − parent_ts > limit), i.e. exactly one of the two blocks is more than limit seconds after the parent. Such a pair is not an equivocation (§3 step 9 refuses the report; §4 makes no charge): the earlier block could never be selected once the limit had passed, so the later one is the legitimate resume of a stalled chain. Two headers both within the limit, or both past it, still convict. The header timestamp is the int64 LE at offset 4 of the signed bytes (after the version).

How to compute it. t = int64 LE at offset 4 of the header; exempt = (t1 − parent_ts > limit) XOR (t2 − parent_ts > limit), with limit = the max_recovery_interval_seconds row, else 3,600.

Rule activation. equivocation_resume_exempt, active from height 0 on every chain.

Rejections and errors. None of its own; it turns §3 step 9 into a refusal of the report. A failed read of the parent's timestamp is an error, not "not exempt". The parent is held by every node judging a report (§3: the evidence window), and the blocksmith side (§1) and the report side (§3, §4) use the same rule.

Vector. computed: parent P.ts = 1,000,000,000; limit 3,600; header1 P.ts + 15 (within), header2 P.ts + 3,601 (past) → straddle → exempt; header1 P.ts + 15, header2 P.ts + 30 (both within) → not exempt, convicts; header1 P.ts + 3,601, header2 P.ts + 7,200 (both past) → not exempt, convicts.

Test cases · §5

4 cases · 4 valid

Parent at 1,000,000,000, limit 3,600: headers at +15 and +360135-5-straddlevalid

Loading the test widget…

Parent at 1,000,000,000, limit 3,600: headers at +15 and +3035-5-both-withinvalid

Loading the test widget…

Parent at 1,000,000,000, limit 3,600: headers at +3601 and +720035-5-both-pastvalid

Loading the test widget…

Parent at 1,000,000,000, limit 3,600: headers at +3600 and +1535-5-at-limitvalid

Loading the test widget…

Defects to match. None.

§6 The peer-side verdict and ban

Purpose. What a node does the moment it sees the two blocks on the wire, before any report is mined.

Inputs. Two blocks pushed or relayed (27); the blocksmith's registration; the in-memory equivocation ledger; this node's tip.

Output and effect. The wire check (run on the SendBlock and candidate paths) ignores a block at height 0 and a block outside [tip − 720, tip + 2]; otherwise it notes the header in an in-memory ledger keyed (previous_block_hash, blocksmith_public_key) only when its signature verifies under the blocksmith key and the blocksmith is a registered node — so a stranger cannot plant a fabricated first header to get a real blocksmith's real block dropped. A height holds at most 256 (parent, blocksmith) pairs; a further first header at that height is not kept. On a second, different verified header for the same (parent, blocksmith) the node, in one pass: (a) unless the pair straddles the recovery limit (§5, a resume: no ban, no report), records the blocksmith (not the relaying peer) as a proven liar — it blacklists the blocksmith's key as a peer (28) and disconnects it; (b) once per (parent, blocksmith) from this node (a set of at most 4,096 reported pairs, cleared when full), builds and submits the EquivocationReport of §2 when equivocation_miss is active at tip + 1; and (c) lets the block proceed to validation anyway — it is not dropped, because first-seen differs per node and dropping would fork the honest ones; fork choice (24, tie-by-hash) picks the surviving block.

How to compute it. As 27; the check always lets the block proceed; its effect is the ledger note, the blocksmith ban and the report. Node-local: first-seen differs per node, so the two branches can briefly coexist until fork choice resolves them; the reported set is cleared wholesale at 4,096 entries, so a node may submit a second report for a pair, which the chain then refuses (§3 step 13).

Rule activation. equivocation_miss gates the report submission and the charge (§3, §4); the ban is node-local and has no rule. equivocation_resume_exempt gates the exemption.

Rejections and errors. None at the wire (the block is accepted for validation); the report inherits §3's.

Vector. computed: a registered blocksmith that signs two headers over one parent is blacklisted by every node that relays both, and the first such node per (parent, blocksmith) submits the report that charges it one miss at the next block.

Test cases · §6

2 cases · 2 valid · 2 reference

The wire check's bounds35-6-wirevalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

height_window
[tip - 720, tip + 2]
pairs_per_height
256
reported_set
4096 (cleared when full)
block_dropped
never
banned
the producer key, unless the pair straddles the recovery limit
A registered blocksmith that signs two headers over one parent35-6-outcomevalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

value
blacklisted by every node that relays both; the first such node per (parent, producer) submits the report that charges one miss at the next block

Defects to match. None.

§7 The SpineEquivocationReport (type 62)

Purpose. Charge a spine signer that voted both ways on one spine block candidate: a spine signature on the candidate (its "yes") and a non-signing statement on the same candidate at the same spine height (its "no", 25 §6b). Signing two different candidates at one spine height is not reportable: a signer freed by enough non-signing statements may sign a new candidate (25 §6a), so the report carries one header only.

Inputs. The candidate's signed header bytes (the bytes a spine signature covers: 204 bytes, or 284 with the seed proof, 25 §1 / 05); its identity = SHA3-256 of those bytes; the signer's node key; its Ed25519 spine signature over the bytes; its Ed25519 signature over the non-signing digest SHA3-256(ASCII "ZBC-SPINE-REFUSE" (16 bytes) ‖ genesis hash (32) ‖ spine_height (uint32 LE) ‖ identity (32)) (25 §6b, 27 §12); the spine height H the statement names; the node registry as of the block before; the spine_equivocation_charge table.

Output and effect. A transaction of type 62 (SpineEquivocationReport), version 1, survival 0, fee 0 (a fee-free duty, 04; a node-signed type), sender 00000000 ‖ node_public_key (the typed node-key account of the node that sends the report). Its body, with no trailing bytes:

offset length field encoding
0 4 spine_height H uint32 LE; ≥ 1
4 32 node_public_key the spine signer both signatures are by
36 4 header_len L uint32 LE; 204 or 284
40 L header the candidate's signed header bytes; identity = SHA3-256 of them
40 + L 64 spine_signature Ed25519 by node_public_key over header
104 + L 64 statement_signature Ed25519 by node_public_key over the non-signing digest at H for that identity

Total = 168 + L: 372 bytes for a 204-byte header, 452 for a 284-byte one. The parser refuses a body under 40 bytes ("SpineEquivocationReport body too short"), an L of 0 or above 4,096 ("SpineEquivocationReport header length out of range"), and any body whose length is not exactly 40 + L + 128 ("SpineEquivocationReport: the body must be the header and two 64-byte signatures, nothing more").

Validity, judged at height h (admission: tip + 1; in a block: its height), from the transaction and the main chain's registry only — never from the spine chain, which a node may not have synced — so every node reaches one verdict. In order:

  1. fee == 0 by the general check of a node duty's fee, which runs first ("Transaction fee must be exactly 0: a node duty declares a fee of exactly zero (this one declares F)").
  2. spine_equivocation_report active at h ("SpineEquivocationReport needs rule spine_equivocation_report (active from height …)"); the type's own fee check ("SpineEquivocationReport: duty transactions are fee-free (fee must be 0)") is unreachable past step 1.
  3. The body parses (the three strings above).
  4. H ≠ 0 ("SpineEquivocationReport: spine height 0 has no candidates").
  5. L is 204 or 284 ("SpineEquivocationReport: the header must be the signed header bytes (204, or 284 with the seed proof)").
  6. spine_signature verifies as Ed25519 over header under node_public_key ("SpineEquivocationReport: the spine signature does not verify under the voter's key").
  7. statement_signature verifies as Ed25519 over SHA3-256("ZBC-SPINE-REFUSE" ‖ genesis hash ‖ H as uint32 LE ‖ SHA3-256(header)) under node_public_key ("SpineEquivocationReport: the non-signing statement does not verify for that candidate and spine height"). This is what binds the two votes to one candidate at one spine height: a statement on another candidate, or at another height, does not verify.
  8. node_public_key is a registered node (status ≠ Deleted) as of h − 1 ("SpineEquivocationReport: the voter key is no registered node").
  9. The sender — the node key of its typed account — is a registered node as of h − 1 ("SpineEquivocationReport must be sent by a registered node's key").
  10. The pair (node_id of node_public_key, H) has no spine_equivocation_charge row with height ≤ h − 1 ("SpineEquivocationReport: this node is already charged for that spine height").

A read that fails (the registry, the charge table) is a fault on this node, never "not charged". Nothing in the verdict requires the header to be a candidate the spine chain stored or could store: the signer's two signatures are the whole proof, and an honest node never signs a non-signing statement on anything but a real candidate for the spine height it is collecting (a candidate that builds on its own spine block at H − 1, by the spine blocksmith the selection draws, at a valid spacing, with a verifying blocksmith signature; 25 §6b), so it never produces both votes on one identity.

Execution at block H': with spine_equivocation_report active: the node registered under node_public_key as of H' (none → no-op; a failed read → the block fails); a spine_equivocation_charge row for (node_id, H) with height ≤ H' → no-op; else write spine_equivocation_charge(node_id, spine_height = H, reporter = the sender account, height = H') and, when liveness_miss_rule is accumulating at H', charge the node one liveness miss (§4: missing until its next own block, the fourth consecutive miss suspends it). No stake is taken; no ledger row is written; the report touches no account (07 §12).

Data model. spine_equivocation_charge: node_id (64-bit signed integer), spine_height (32-bit), reporter (bytes, 36), height (32-bit: the main-chain block that wrote it); (node_id, spine_height) is the key; a second write for a pair is ignored; a pop-off to target deletes the rows with height > target. A snapshot state table (26); it is its own table because spine heights are not main-chain heights. The fork weigher replays the charge along a competing branch once per (node_id, H) not already charged in the shared history (24, 36 §11).

The duty lane and the wire. The pool keeps one pending report per (the sender's node key, node_public_key, H) (the duty key of 04 §6 extended with the body's first 36 bytes) and relays it like any duty (28). The node that collects spine signatures for a candidate (the spine blocksmith, 25 §5) and holds, for one key, both a spine signature on the candidate and a non-signing statement naming the candidate's identity at its height, builds one report per such key from the candidate's signed header bytes and submits it to its own pool when the rule is active at tip + 1; a statement on another identity or another height yields nothing. A node records every non-signing statement it gives in a node-local table (spine_refused: spine height, identity; at most 1,024 statements per height) before it signs it, gives no statement when the record cannot be written, and never signs a candidate it has stated it did not sign nor states it did not sign one it signed (25 §6a–§6b): the record is what keeps an honest node from ever voting both ways after a restart.

How to compute it. 1. Parse H, node_public_key, L, header, the two signatures; check the exact length. 2. identity = SHA3-256(header); verify the spine signature over header; verify the statement over the non-signing digest at H with the chain's genesis hash. 3. Read the registry as of h − 1 for the voter and the sender. 4. Check the charge table. 5. At execution: the row and the miss.

Rule activation. spine_equivocation_report (active from height 0 on every chain; it gates type 62), liveness_miss_rule (the miss).

Rejections and errors. The strings of the parse and of the ten steps above; mined anyway, a report that fails any of them makes the block invalid.

Vector. computed (script spine_equivocation_report_62 kept with the edition's vectors; the genesis hash is the example value G = 11 × 32: a chain substitutes its own).

  • INPUT: the signer's node key from the Ed25519 seed 2252ecf5785857fb892d18788f04d355c5f41f8815874ee88382860d6ce82d4a (= SHA3-256 of the ASCII ZooBC spec vector spine signer key): node_public_key = 85d66426e016158cc09ea2d932756a78040edfe0594f26f5016afa30400b9fc5. The candidate's 204 signed header bytes P: every byte 0 except bytes 0–3 01000000 (version 1), bytes 4–11 23bbea6a00000000 (timestamp 1,793,768,227), bytes 76–107 22 × 32 (the spine blocksmith's key) and bytes 172–203 33 × 32 (the previous spine block's hash). Spine height H = 7.
  • EXPECTED OUTPUT: identity(P) = 8e1678c7246364493b27808788d397ced3ea58b6703ac9ba0a87fb8c85435aab; spine_signature = f64264d066206d85a5c19493d436881b5efdb65f3a9f2849d662f4b0a169d17c6284986aae7cc55d15d66af412617eea41f357ca68825cdc3345d6c1e0601206; the non-signing digest at 7 = SHA3-256(5a42432d5350494e452d524546555345 ‖ G ‖ 07000000 ‖ identity) = 5988d937948a2aad57021d701a36fea2612c28a5b95e4dc814350cba1e52eb01; statement_signature = 1ea1e13a454697370d9ab718ee7c80af1cbcf27da29dc477d4402497ef9ee4b0f3960802f31aadf67836ea5fe9d9eb81e75e5f2102fd062bafc102858c21bd0c; the body is 372 bytes, beginning 07000000 ‖ 85d66426…0b9fc5 ‖ cc000000 ‖ P, with the spine signature at offset 244 and the statement signature at offset 308; SHA3-256 of the body = f353f552df4137663ad289d5c93edfa38eb7d713efe668650002c17b9eed5416. Sent with fee 0 from a registered node's key, the voter registered, no charge row: valid; the row (node_id, 7) is written and the node is charged one miss.
  • INVALID INPUT: the body with one byte 00 appended (373 bytes), or cut to 371 → SpineEquivocationReport: the body must be the header and two 64-byte signatures, nothing more.
  • INVALID INPUT: the body with spine_height changed to 08000000 → SpineEquivocationReport: the non-signing statement does not verify for that candidate and spine height (the digest at 8 is a9e199f2b4b7cdce7f3dd4588b10ab782b6aa37642af980664af7cc2bb88ebb2, which the statement does not sign).
  • INVALID INPUT: the statement replaced by the signer's statement on Q = P with bytes 4–11 24bbea6a00000000 (identity 19f358eb55ce8e6c96de3793f0cf713d4fe14119367b55204d527aa0d2f8a591) → the same refusal: a "no" on another candidate is no contradiction. The spine signature replaced by the signer's spine signature on Q (two candidates signed) → SpineEquivocationReport: the spine signature does not verify under the voter's key: not reportable.
  • INVALID INPUT: the valid body sent again after it was mined → SpineEquivocationReport: this node is already charged for that spine height; the valid body with fee 1 → Transaction fee must be exactly 0: a node duty declares a fee of exactly zero (this one declares 1).

Test cases · §7

16 cases · 5 valid · 11 invalid · 2 reference

A spine signer gives a spine signature and a non-signing statement on one candidate at spine height 735-7-signature-and-non-signingvalid

Loading the test widget…

The body with one byte 00 appended (373 bytes)35-7-appendedinvalid

Loading the test widget…

The body cut to 371 bytes35-7-cutinvalid

Loading the test widget…

The body with spine_height changed to 835-7-height-8invalid

Loading the test widget…

The non-signing digest of the same candidate at spine height 835-7-digest-8valid

Loading the test widget…

The statement replaced by the signer's statement on another candidate Q35-7-statement-other-candidateinvalid

Loading the test widget…

The identity of the other candidate Q35-7-candidate-qvalid

Loading the test widget…

The spine signature replaced by the signer's spine signature on Q (two candidates signed)35-7-two-spine-signaturesinvalid

Loading the test widget…

The valid body sent again after it was mined35-7-chargedinvalid

Loading the test widget…

The valid body with fee 135-7-feeinvalid

Loading the test widget…

The statement and the body at spine height 035-7-height-0invalid

Loading the test widget…

A candidate header of 203 bytes35-7-short-headerinvalid

Loading the test widget…

The signer's key is no registered node35-7-voter-unregisteredinvalid

Loading the test widget…

The sender is no registered node35-7-sender-unregisteredinvalid

Loading the test widget…

The stated sizes of a SpineEquivocationReport35-7-sizesvalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

with_204_byte_header
372
with_284_byte_header
452
type
62
version
1
fee
0
survival
0
statements_recorded_per_spine_height
1024
The spine_equivocation_charge row35-7-tablevalidreference

A stated value: there is nothing to compute. A compatible node shows the same value.

key
(node_id, spine_height)
columns
node_id int64, spine_height uint32, reporter 36 bytes, height uint32
pop_off
rows with height > target are deleted
stake_taken
none

Defects to match. None.

§8 Consensus and local; summary of defects

Consensus: the EquivocationReport body and type gate (§2), its validity (§3), the charge and the equivocation_charge rows (§4), the resume straddle rule (§5), and the SpineEquivocationReport, its validity, its charge and the spine_equivocation_charge rows (§7) — an implementation that differs on any of these accepts a report the fleet rejects, or charges a node the fleet does not, and forks. Local: the blocksmith's guard and its producer_signed_parent table (its record of the parents it signed over, §1), the wire ban (§6), the in-memory ledger, the collector's building of spine reports and a node's record of its own non-signing statements (§7).

The rules equivocation_miss, equivocation_resume_exempt, spine_equivocation_report and liveness_miss_rule are active from height 0 on every chain.

Defects an implementation must reproduce or know about: (1) the charge is once per (blocksmith, height) and once per (signer, spine height), not once ever (§4, §7); (2) the resume exemption lets a resume over an old parent go uncharged (§5); (3) a proven double-sign or double vote costs a miss and the missing state until the node's next own block, never stake (§4, §7); (4) spine signatures on two different candidates at one spine height are not an offence (§7).

A question about this chapter, or a statement that does not match the network? Discuss on zoobc.pro.