igneum/docs/spec/03-finality.md

# Igneum protocol specification, section 3: sustained-mining finality, version 2

Spec version 0.1, 3 October 2026. Status of this section: Designed. Simulated at the checkpoint level with latency, partitions and eclipses but without a DAG (`sim/finality_v2.py`, `sim/results_v2.md`, `docs/bench-log.md` entry "sim/finality_v2.py"). Not implemented. Not externally reviewed. Gate 3 is the external review that tries to break it.

The rule is exactly the design document's "Finality rule, version 2, after the second hostile review" with the quorum floor added on 3 October 2026 after the second simulation. CLAUDE.md's FINALITY RULE V2 paragraph is the short form. Every quantity is in blue score, DAA seconds or past-median time, never wall-clock (section 0.6). Past-median time, `mt(B)`, is the median timestamp of a block's sampled past (Kaspa's `consensus/src/processes/past_median_time.rs`, `PAST_MEDIAN_TIME_SAMPLE_INTERVAL` 10, kept): consensus data computed from the block's past, which a burst of blocks cannot run fast the way it runs DAA score (ledger M14 and F14, round 3).

Two statements frame everything below. Finality is miner-only and self-contained: no stake, no bond, no other chain, no committee that is not the set of recent miners. Equivocation costs history, not coins, because there are no coins to slash.

## 3.1 Weight

- **W1.** Every block header names a vote key by `vote_key_hash` (section 2.4): the hash of a BLS12-381 G1 compressed public key. The first block that uses a key reveals the key in its coinbase payload. A header whose `vote_key_hash` has never been revealed is valid; the key simply cannot vote until it is revealed.
- **W2.** Weight is counted in blocks and denominated in past-median time (rule of 3 October 2026, ledger M14 and F14, round 3; the simulated form is kept below). Cut the trailing 30 days of past-median time before C, `(mt(C) - 2,592,000 s, mt(C)]`, into 43,200 buckets of 60 s; a blue block in C's past falls in the bucket that holds its own past-median time. The weight of key k at C is the sum over buckets of k's share of the blue blocks in that bucket (an empty bucket contributes 0 to everyone). A bucket is worth 1 whatever it holds, so 50x the blocks in one minute is one minute of weight, and a retarget lag can neither inflate a key's count nor age the window. No damping, no cap, no floor. Blocks are the only thing in proof of work that cannot be forged, so weight is counted in blocks; time is the denominator because blocks per unit of DAA time is exactly what a lagging controller lets a renter buy (section 2.3; `docs/review/round-3-2026-10-03.md`, "Tonight's devnet"). As simulated (`sim/results_v2.md`, every run): the number of blue blocks in C's past whose header names k and whose DAA score is in `(daa(C) - 2,592,000, daa(C)]`. The two forms agree whenever the controller holds the target; O-3.14 runs the simulation under both with the DAA in the loop and confirms or reverts this rule at gate 3. The damped rule of version 1 was removed because its 2x cap was defeated by splitting into free keys (`sim/results.md` table C; `docs/bench-log.md` finality_sim entry).
- **W3.** Dust: a key with fewer than 100 blue blocks in the window (a block count, not bucket weight) is not a voter and is in no denominator. Measured consequence (`sim/results_v2.md` A and G): every honest key in a 1,000-key Pareto network clears 100 blocks by day 20 from zero history and the smallest new keys need up to 25 days after a doubling; a 9x renter's victims lose about one point to dust (B).
- **W4.** Steady state: weight equals hashrate. Simulated correlation 1.00000 at day 60, Gini equal to three figures, weight-to-hash ratio within 0.82 to 1.12 for every key (`sim/results_v2.md` A).
- **W5.** Key succession: a message signed by the old key naming a new key, included in any block, moves the old key's weight history to the new key once. The old key is dead thereafter: its later blocks earn nothing and its votes are invalid.
- **W6.** Keys are free. Nothing in the protocol prices a vote key and the devnet launcher mints one per worker process (ledger F17, round 3). Weight is the only Sybil-resistant quantity in this specification, so every rule that draws from the voter population draws by weight and never per key: W2 (no damping, no per-key cap), the shard sortition of section 7.2 (drawn by weight since 3 October 2026) and the sub-user sortition of S2. A rule that counts keys is a rule a splitter wins.

The headline arithmetic (W2 with constant hashrate): an attacker with share a of hashrate for t days holds weight share `(t/30) x a/(1+a)`, verified by simulation to 0.04 points for a = 1 and 2 (`sim/results_v2.md` B).

| Attacker hashrate relative to honest (a) | Reaches 1/3 (can veto) | Reaches 2/3 (locks alone) |
|---|---|---|
| 1x (50% of blocks) | day 20.0 | never (ceiling 50%) |
| 2x (67%) | day 15.0 | day 30.0 |
| 4x (80%) | day 12.5 | day 25.0 |
| 9x (90%) | day 11.1 | day 22.2 |
| unbounded (100% of blocks, honest miners gone) | day 10 | day 20 |

All in public, on the hashrate charts. 51% never reaches 2/3 while honest miners keep mining.

## 3.2 Checkpoints

- **C1.** Checkpoint i is the selected-chain block at blue score 30 i. It is determined once the virtual's blue score reaches 30 i + d. d = 60 at 1 block per second is a placeholder (ledger F7): the gate 3 devnet records the reorg-depth distribution and sets d so that a vote split at one index is rare and self-heals at the next. d scales with block rate. A lock lands about 90 to 120 s after a transaction (Designed; simulated lock latency after the checkpoint block is median 2.5 s, p99 4.6 s at a 2-s inter-region delay, `sim/results_v2.md` A).
- **C2.** A vote is a BLS signature over `(chain_id, i, hash(C_i))` under a fixed domain-separation tag. Votes gossip as their own message type.
- **C3.** A lock certificate for index i is an aggregate BLS signature over one checkpoint block hash with a bitmap of signers, whose signed weight meets Q3. Every block carries the highest certificate its producer knows. A block whose selected chain does not pass through every certified checkpoint in its past is invalid (section 2.4).
- **C4.** A node holding a certificate for index i rejects any other certificate for index i and publishes the pair as evidence (section 3.6).
- **C5.** No certificate may form in the chain's first 3,600 DAA seconds (design document). See 3.8 for the proposed first-month rule.

## 3.3 Quorum

- **Q1.** Presence window P = 7,200 s of past-median time: index j is in the window of index i when `0 < mt(C_i) - mt(C_j) <= 7,200`. About 240 indices at the target rate. Denominated in median time, not indices or DAA seconds, so a burst of blocks cannot shrink the window to minutes (ledger M14 and F14, round 3; the simulation ran with a fixed 240 indices).
- **Q2.** Participation of key k at index i, "block reading" (rule of 3 October 2026, ledger F3): the number of indices j in the presence window of i (Q1) for which a valid vote by k at index j appears in the past of C_i, divided by the number of indices in that window, capped at 1. A vote "appears in the past of C_i" when it is carried, as a vote or inside a certificate, by any block in the past of C_i, blue or red. A key whose first block is younger than the presence window counts 1. Votes are block payload: every block MUST carry every valid vote its producer has received for i_b or an index in its presence window (i_b the highest checkpoint index determined in the block's past) that is not already carried by a block in its past, up to the per-block vote bound of O-3.3; votes for one `(index, checkpoint hash)` pair MAY be aggregated inside the block into one BLS signature with a bitmap. A block that omits a vote it has received is not invalid (no node can prove what another received); the rule binds honest producers and the argument of 3.3.2 says why that is enough. This reading is objective, since every node computes it from the same past of C_i, and self-healing, since a missed index rolls out of the window after two hours of median time. The "cert reading" of the simulation (only votes inside certificates count) is a subset of it and was the reading the simulation ran with; the node-local "seen" reading is rejected as not objective and the "frozen" reading as total with extra steps (`sim/results_v2.md`, "Recommended parameters").
- **Q3.** Active weight at i is the sum over voters of weight x participation. Total weight at i is the sum of weight over all keys above dust. A certificate for index i locks when the unscaled weight of its signers is at least **2/3 of active weight** AND at least **56.7% of total weight** (the floor 0.85 x 2/3 = 17/30). Both tests use weights and participation computed at C_i, so any node can verify a certificate from C_i's past.
- **Q4.** Certificate grace: an aggregator closes a certificate at the later of quorum time and `t0 + grace`, where grace MUST be at least 3x the worst honest one-way network delay (15 s in the simulation at a 2-s delay; at a 5-s delay the slowest region already lost 1.7 points of participation to a 15-s grace, `sim/results_v2.md` A). The value is Open (O-3.4) and does not affect validity, only which votes a certificate carries.

### 3.3.1 Why the floor, from the simulation

Both denominators alone fail (`sim/results_v2.md`, seed 7, seed 11 agrees on B and E):

| Scenario | Active alone (cert reading, P = 240) | Total alone | Active + floor 0.85 |
|---|---|---|---|
| E: 50/50 honest partition, no attacker, 150 min | 90 conflicting locks, first at 60 min (240 with instant DAA retarget, first at 30 min) | 0 | 0 |
| E: 60/40 honest partition, 360 min, with retarget | 624 conflicts | 0 | 0; majority side locks from minute 13 |
| E: 33/33/34, 360 min, with retarget | 1,198 conflicts | 0 | 0 |
| F2: 34% attacker poisons one eclipsed 20% pool, 1 / 2 / 4 h | 10 / 65 / 174 conflicts, first at 49 min | 0 | 0 (floor 0.80 gave 10 / 65 / 174, because the eclipsed side's 54% clears 53.3%) |
| C: 34% of weight silent, keeps mining | 0 min to first lock, 0 stalls | never (8,666 stalls in 3 days, and for the whole window) | 0 min |
| C: 40% silent | 13 min, 26 stalls | never | 13 min, 138 intermittent stalls in 3 days |
| C: 45% silent | 20 min | never | never, for as long as they stay silent |
| D: 35% churn (stops mining and signing) | 2 min | 41 h | 2 min, 98 intermittent stalls in 3 days |
| D: 50% churn | 31 min | 10.1 days | 4.1 days (floor 0.80: 2.2 days) |

The mechanism active alone fails by: a side that cannot see the other side's votes sees stalls, stalls shrink its denominator by 1/240 per index, and once the denominator has fallen to 1.5x the side's own weight the side certifies alone, after `240 x (1 - 1.5 s) / s` slots for a side of share s (confirmed within 5% across the sweep): 60 min for a 50% side, 120 for 40%, 180 for 33%. The floor makes the second test of Q3 bind before that point: no honest side of any tested split holds 56.7% of total.

What the floor costs: liveness ends between 40% and 45% of weight silent (total alone: 34%; active alone: above 55%), 50% churn stalls 4.1 days, and at 40% silent or 35% churn the margin is one pool outage thin. The safety bound stays at 1/3 of weight for every event tested; the liveness bound moves from 1/3 (total) to about 42% silent.

The simulation ran with the cert reading of participation. The block reading of Q2 credits a superset of the same votes (every vote in a certificate is in a block, and votes carried outside certificates are added), so a key's participation under the block reading is never lower than under the cert reading. For a key that is silent (C) or gone (D) nothing changes, because it emits no votes. For a key whose votes arrive late (F1 below) the block reading keeps it in the denominator for longer, which raises the weight a lock needs. That direction is safe; its cost in lock latency and in the C and D stall figures is the re-run named in O-3.3, with the per-block vote bound as the parameter.

### 3.3.2 The eclipse case (ledger F2): closed by the floor

Decision of 3 October 2026. The presence window of Q1 is an eclipse vector on its own: a faction that keeps the big pools' votes from the rest of the network for two hours, without stopping their blocks, becomes the whole of active weight and locks alone. The answer is not a longer window or a silent-key rule; it is the second test of Q3, already in the rule. A lock needs at least 56.7% of total weight whatever the presence window says, so an eclipsed or isolated faction can never lock unless it holds a majority of all 30-day weight, and a faction that holds that much is a public 51% event of 3.1, not an eclipse.

The numbers (`sim/results_v2.md`, section F, seed 7, 1,000 keys, one pool holding 20% of total weight always online in its own region):

| Scenario | Denominator | Conflicting locks at 1 / 2 / 4 h | First conflict | Pool participation, minimum | Pool back to 1 after the eclipse ends |
|---|---|---|---|---|---|
| F1: pool receives every block and vote D hours late and votes correctly, late | any | 0 / 0 / 0 | never | 0.500 at 1 h, 0.000 at 2 and 4 h | 120 to 125 min |
| F2: a 34% attacker feeds the pool a private fork, signs both forks; eclipsed side holds 54% of weight, honest side 46% | active alone (cert reading) | 10 / 65 / 174 | 49 min | 0.787 / 0.562 / 0.108 | 115 / 85 / 20 min |
| F2, same | active + floor 0.80 (lock needs 53.3% of total) | 10 / 65 / 174 | 49 min | same as active alone | same |
| F2, same | **active + floor 0.85 (lock needs 56.7% of total, rule Q3)** | **0 / 0 / 0** | **never** | 0.738 / 0.471 / 0.000 | 125 min |
| F2, same | total alone | 0 / 0 / 0 | never | 0.738 / 0.471 / 0.000 | 125 min |

Why 0.85 and not 0.80: the eclipsed side in F2 holds 54% of total weight, which clears a 53.3% floor and fails a 56.7% one. Under the active denominator alone the eclipsed view certifies the attacker's fork 49 minutes in, once its denominator has decayed below 54% / (2/3) = 81%; the 0.85 floor binds before that point at every eclipse length tested, and the honest side saw 0 stalls during and after the heal in every row. A pure delay (F1) never produced a conflicting lock under any denominator because 80% of weight kept signing; its only cost falls on the delayed pool, which leaves the denominator and returns to participation 1 about two hours after its view catches up.

What this does not prove. The model grants the attacker the eclipse for free and lets it mine its fork at its full rate for the pool alone while still signing the honest chain (`sim/results_v2.md`, "cannot tell us"). The attacker in F2 holds 34%, above the 1/3 safety bound of 3.7, which is the point: with the floor, even a faction above the bound cannot turn an eclipse into a conflicting lock. The devnet single-node eclipse of O-3.7 confirms the rule against a real network; it does not reopen the choice of rule.

## 3.4 Sortition

- **S1.** At launch every voter signs every checkpoint. A private VRF, keyed to the vote key and the checkpoint, selects 8 aggregators per checkpoint who publish certificates; anyone MAY aggregate and publish. Aggregator failure costs latency, not safety: the simulation's lock latency (median 2.5 s) assumes one aggregator per region and no failures, so it is a lower bound (`sim/results_v2.md`, "cannot tell us").
- **S2.** If the number of voters above dust exceeds 8,192 at a checkpoint, the genesis rules switch, at that checkpoint and without a release, to Algorand-style binomial sub-user sortition with an expected 4,000 sub-users per checkpoint and both Q3 thresholds applied to expected sampled weight. The exact VRF construction, the binomial sampling procedure and the threshold on sampled weight are Open (O-3.5).

### 3.4.1 Participation grinding (ledger F3): closed by the block reading

Decision of 3 October 2026. Under a cert-only reading, whoever aggregates and whoever produces blocks could shape a rival's participation: drop its votes from the certificates you publish and carry, and after two hours its factor has fallen and your share of active weight has risen. Q2 closes this by computing participation from every vote seen in blocks over the presence window, never only from the votes an aggregator chose to certify. Aggregators choose what goes into a certificate; they choose nothing about participation.

Why an aggregator or a block producer cannot push a key's participation below the honest level:

1. A vote is credited if it appears in any block in the past of C_i, blue or red, as a vote or inside a certificate. Certificates are one carrier among many, so the aggregator's bitmap selects nothing. An aggregator that drops a vote from its certificate changes which certificate locks (Q3 still has to be met by the votes it kept), not whether the vote counts for presence.
2. A single block producer controls one block's payload. To keep k's vote for index j out of the past of C_i, every producer of every block that ends up in the past of C_i, over the about 240 indices between j and i, has to omit it, and the rule of Q2 makes every honest producer carry it. Under GHOSTDAG the past of C_i includes red blocks and every block merged within the 3,600-s bound, so an honest block that carries the vote is in the past of C_i within an hour of being mined.
3. k is a voter only if it holds weight, which means it mined at least 100 blue blocks in the window. k carries its own votes in its own blocks, so suppressing k's participation means keeping k's own blocks out of the DAG for the whole presence window. That is excluding a miner from the chain for two hours, which is the eclipse of 3.3.2, where the floor already stops a lock, or a majority attack of 3.1, which the rule never claimed to survive.
4. Nobody can raise participation falsely, because a vote is a BLS signature by k. Nobody can be made to vote twice at one index without producing equivocation evidence (3.6).

The honest level is therefore the number of indices at which k actually voted and its vote reached any honest producer within the window. A producer that receives votes and omits them lowers nothing while one honest block carries them; it only spends its own block space on less. The per-block vote bound, the window the carriage rule covers, and the lock latency and C and D stall figures under the block reading are the parameter re-run of O-3.3.

## 3.5 Fork choice

- **F1.** Candidate tips are tips whose selected chain passes through the highest certified checkpoint the node holds and every lower certified checkpoint.
- **F2.** Among candidates, GHOSTDAG selects by accumulated blue work under Kaspa's merge-depth bound of 3,600 DAA s (section 2.1). A certified checkpoint removes other tips from candidacy; it does not change how blue work is computed.
- **F3.** The pruning point never advances past the latest certified checkpoint. `virtual_finality_point` returns the latest certified checkpoint when it is newer than the depth-based finality point (fork map e2).
- **F4.** There is no hidden-block penalty in consensus. It was removed in review round 2 because it breaks DAG determinism and amplifies eclipse attacks. First-seen MAY break ties in a node's own block template only.
- **F5.** A node started with a configured trusted certificate follows it. A node started cold selects the DAG with the most accumulated blue work, then follows certificates found in it. A private DAG that out-works the public one over the window is a public 51% event lasting weeks.

What a node does when it holds two valid certificates at one index after a partition heals is not modelled and not defined (`sim/results_v2.md`, "cannot tell us"; O-3.6). C4 says it publishes the pair. The proposal for gate 3: both certificates are evidence against every key that signed both; the node re-evaluates both against Q3 with those keys' weight struck, and if exactly one still locks it follows that one; if neither or both still lock, F2 decides among the two checkpoint blocks' descendants and the index is treated as uncertified.

## 3.6 Equivocation evidence

Two votes by one key for different checkpoint blocks at one index are equivocation. The evidence (the two votes) is a transaction that any block MAY include. On inclusion: the key's weight is zero for the rest of the current window and its blocks earn no weight for the next 2,592,000 DAA s. There is no coin penalty. In the simulation, evidence is detected only at the heal and the penalty is forward-looking only; the model does not revoke the conflicting certificates (`sim/results_v2.md`, "cannot tell us"), which is why 3.5's post-heal proposal strikes the equivocators' weight retroactively for the re-evaluation.

## 3.7 Residual risks, stated

1. Safety holds with under one third of window weight under hostile keys. Reaching a third takes ten days of 100% hashrate or twenty days of 51%, in public. Beyond a third, two locks can coexist under a partition (E: a 34% equivocator across a 50/50 split breaks every variant, 33% + 34% = 67% per side) and equivocation costs history, not coins.
2. Liveness pauses after a sudden loss of more than about 42% of weight from signing (3.3.1). During a pause the chain is proof-of-work only in practice, so the node ships a flag that tells exchanges to credit nothing until the next lock (3.9).
3. Pools hold their hashers' votes. Vote concentration equals pool concentration, as on Bitcoin, and is public. Stratum v2 job declaration changes transaction choice, not the vote key (ledger F10, G6).
4. A 51% owner who drives half the honest miners away and holds for 30 days owns finality thereafter. Same as Bitcoin, with a month's warning.
5. The delay function (section 4) is a new dependency. The evaluator ships in every node.
6. The dust threshold excludes solo miners under 100 blocks a month from voting, not from rewards.
7. New honest miners are under-weighted for the whole window: after an overnight doubling the new cohort holds t/60 of weight on day t and the old cohort can lock without a single new signature for 19 days (`sim/results_v2.md` G). A doubling and a 1x renter are the same event to the rule, by design.
8. The simulation has no DAG: a partition side's checkpoint block is "the block at blue score 30 i in that view" and conflict counts are index collisions, not reorg depths. Real GHOSTDAG merge under the 3,600-s bound, DAA lag (of the order of an hour, approximate), VRF aggregator noise, uptime (the 0.978 resting participation is a guess), regional silent sets and the cost of keys are all outside the model.

## 3.8 The first month

W2 gives the chain no weight at genesis. From zero history the honest network holds 3.3% of a full window on day 1, 33.4% on day 10 and 100% on day 30; 905 of 1,000 keys are under dust on day 1 and all are above it by day 20 (`sim/results_v2.md` A). Ledger F1 shows the consequence: with a one-day honest head start an attacker producing 75% of blocks from day 2 crosses two thirds on day 9 of the chain's life, and the 30-day emission ramp lowers the prize without removing the attack.

Two rules are on the table:

| Rule | Status |
|---|---|
| C5 as written: no certificate in the first 3,600 DAA s | Designed (design document) |
| No certificate may form until the window holds 30 days of history: before DAA second 2,592,000 the chain runs plain GHOSTDAG under the merge-depth and finality-depth bounds, exchanges are told so, and the node flag of 3.9 is false | Proposed (ledger F1), Open (O-3.1). This specification recommends it: the first month has no weight to defend with, so a lock in that month is a lock by whoever showed up, and the finality depth of section 2.1 already bounds a reorg to 12 hours (ledger F15: the merge-depth bound limits which old blocks can be merged, not which chain the node follows) |

Gate 3 decides, with the launch-month simulation that does not yet exist. Either way the litepaper states the rule.

## 3.9 Exchange confirmation guidance

Designed. The node exposes `finality_active` (true when a certificate has formed within the last 240 indices and the first-month rule of 3.8 has passed) and `last_certified` (index, block hash, DAA score).

| Situation | Guidance |
|---|---|
| `finality_active` and the deposit's block is in the past of `last_certified` | Credit. Expected wait about 90 to 120 s after inclusion |
| `finality_active`, deposit not yet covered | Wait for the next certificate; do not count blocks |
| `finality_active` false (first month, or a pause under 3.7 item 2) | Treat the chain as proof of work. The reorg bound to rely on is the finality depth of section 2.1, 43,200 DAA s: the node follows any heavier selected chain forked above it (ledger F15, round 3). Merge depth, 3,600 DAA s, limits which old blocks can be merged and is not a reorg bound. Credit nothing until the deposit's block is at least 12 hours of past-median time below the selected tip; count median time, not DAA score, because DAA seconds run fast during a retarget lag (ledger M14). For amounts that matter apply the operator's own hashrate judgement, as for any young proof-of-work chain. Listings are not sought before launch in any case (ledger X8) |
| Two certificates at one index observed (C4 evidence) | Suspend credits until the node's view resolves under 3.5 |

A certified checkpoint overrides the heaviest chain, so fresh hashrate cannot reorganise past `last_certified`; two thirds of 30-day weight can, and 3.1 says what that costs.

## 3.10 Implementation notes (devnet v2, 3 October 2026)

Status of this section: Implemented in `vendor/igneum-node` (reading guide in `docs/fork-divergence.md`, "Finality v2"), tested on a private four-miner test network and as a follower of the live devnet (`docs/bench-log.md`, entry "igneum-node devnet v2"). Where the implementation departs from the rule above or fills a gap it leaves, the departure is listed here, not silently. Update of 4 October 2026 (branch `fin-fixes`, worktree `vendor/igneum-node-fin-fixes`, after the attack harness of `tools/finality-attacks`): the S1 draw is by weight (ledger F17) and the first-month rule of 3.8 is the `min_daa` parameter (ledger F1); the rows for C5, Q4, S1 and 3.9 below say what landed. Measured in `docs/bench-log.md`, entry "finality fixes F17 and F1" of 4 October 2026.

| Clause | Implementation | Departure or gap |
|---|---|---|
| W1 | `vote_key_hash` = BLAKE2b (domain `IgneumVoteKeyHash`) of the 48-byte compressed G1 key. The key is revealed with a proof of possession in the miner's coinbase extra data (`IGNK` plus 288 hex characters) and a node registers it only when the hash matches the header. A vote carries the public key too, so a key that votes is revealed by its vote | The reveal is hex, not binary, because the template RPC carries extra data as a UTF-8 string. Mainnet should carry the reveal in a dedicated field or transaction |
| W2 | Blue blocks per key in `(daa(C) - window, daa(C)]`, counted along C's selected chain through every chain block's mergeset blues, C included | O(window) per checkpoint: fine at the devnet window of 7,200 DAA seconds, not at 2,592,000. Mainnet needs an incremental window kept per chain block |
| W3, W5 | Dust excludes a key from the voter list and from both denominators | Key succession (W5) is not implemented |
| C1 | Checkpoint i is the lowest selected-chain block with blue score at least 30 i (blue scores along the chain can skip values), determined when the sink's blue score reaches 30 i + d, d = 20 on devnet. A determination is never revisited | d = 20 is below the placeholder 60; the devnet reorg-depth distribution that sets d has not been recorded |
| C2 | BLS signature over `"igneum-vote-v1/" \|\| chain_id \|\| 0 \|\| index \|\| hash(C_i)` under `IGNEUM_VOTE_V1_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_`; the chain id is the prefixed network name (`igneum-devnet`, `igneum-devnet-7`); votes are p2p message 70 and ride in the coinbase extra data of every block | |
| C3 | Certificate = index, checkpoint, voter count, signer bitmap over the canonical voter list (keys above dust and not stripped, sorted by key hash), aggregate signature, aggregator key hash and sortition proof. Every template carries the certificates not yet in its past | The validity rule (a block whose selected chain misses a certified checkpoint is invalid) is NOT enforced; only fork choice (F1, F2) is |
| C4 | A second certificate at an index for another block is kept and logged (`conflicting_certificates`) | Not published as evidence. The rule is now fixed by 3.11 item 4 (the node keeps the certificate it verified first, never re-evaluates it, and reports the conflict); the node does not yet clear `finality_active` or expose `finality_conflict` when the pair appears |
| C5, 3.8 | `min_daa` = `weight_window` (2,592,000 DAA s on mainnet, 7,200 on devnet; a unit test pins the equality). `evaluate` never locks, and `ingest_certificate` refuses a certificate from any source, while the checkpoint's DAA score is below `min_daa`; the node logs "finality not active, window filling, N of M" at every determination until the sink's DAA score reaches `min_daa` and reports the same through `getFinalityCheckpoints` (`finality_reason`, `window_filled_daa`, `window_full_daa`). Unit test `processes::finality::tests::no_certificate_while_the_window_is_filling`: one key holding 100% of the weight signs every checkpoint of a 150-block chain at a 60-DAA window; nothing certifies below DAA 60, a hand-built certificate at an early index is refused, every checkpoint from DAA 60 locks (fin-fixes, 4 October 2026) | Implemented on 3.8's recommendation ahead of the launch-month simulation (O-3.1), which is still not run; gate 3 can lower the gate but not remove it without reopening ledger F1. The sink's DAA score the report compares is the one the virtual processor last handed the manager, so a restarted node reports the window as filling until its first virtual resolution |
| Q1, Q2 | Presence window 20 indices on devnet (240 mainnet). Block reading: participation counts the indices in `[i - P, i - 1]` at which a vote by the key is carried by any block, blue or red, in the past of C_i; a key whose first block in the window is younger than P x 30 DAA seconds counts the full window; every template carries up to 48 votes not already in its past, certificates and evidence first | The per-block vote bound (48) is the devnet value of O-3.3. Participation is credited for any vote by the key at the index, whatever block it names; 3.11.1 requires the vote to name the checkpoint on the crediting chain, else a key can stay in the active denominator by voting for blocks of its own and never add to a certificate (O-3.19) |
| Q3 | Integer tests: `3 x signed x P >= 2 x active_num` (active_num = sum of weight x participation count) and `30 x signed >= 17 x total`, both at C_i; bans known at evaluation time are applied to the voter list | |
| Q4 | No grace. A node that serves an eligible aggregator (S1) aggregates and gossips a certificate the moment the votes it has seen meet Q3, naming that aggregator; any other node waits until the sink is `checkpoint_depth + aggregator_fallback` DAA seconds past the checkpoint block (fallback 15 on both networks) and then aggregates with a zero aggregator (anyone MAY aggregate, the liveness fallback; fin-fixes, 4 October 2026) | The grace timer (O-3.4) is not implemented: the fallback bounds how long a checkpoint waits for its drawn aggregators, it does not hold a certificate open for late votes, so a certificate still often carries fewer signers than the votes that exist (the lock still meets Q3) |
| S1 | VRF output = SHA-256 of the voter's BLS signature over `"igneum-sortition-v1/" \|\| chain_id \|\| 0 \|\| index \|\| hash` under the sortition tag (unique per key and message, so the signature is the proof); eligible when `output x total_weight < 8 x weight x 2^64`, drawn by weight (W6, ledger F17, fin-fixes 4 October 2026): the expected number of aggregators is 8 by weight whatever the key count, a key with no weight never draws, a key holding 1/8 of total weight or more always does (so with 8 or fewer equal voters everyone is eligible). Unit test `sortition_is_by_weight_not_key_count`: 200 dust keys draw nothing, 6 real keys draw `sum min(1, 8 w / T)`, 16 equal keys draw 8.00, a key split into 10 or 200 parts draws what it drew whole | Was `output x voters < 8 x 2^64` (per key) until 4 October 2026; measured on the attack harness (`docs/bench-log.md`, "finality v2 attack harness" S2, then "finality fixes F17 and F1"). A key above 1/8 of total weight that splits itself gains seats (its single ticket was capped at 1); seats carry no reward and no power, since anyone MAY aggregate and Q3 is tested by weight |
| S2 | Not implemented (sub-user sortition above 8,192 voters) | |
| F1, F2 | In `resolve_virtual` the highest locked checkpoint that is in the future of the depth-based finality point and in the past of some body tip replaces the finality point: tips outside its future are not sink candidates | A lock that no body tip passes through is logged and ignored for that resolution |
| F3 | Not implemented: the pruning point and `virtual_finality_point` ignore locks | Must land before any pruning network |
| F5 | Not implemented (trusted certificate at start) | |
| 3.6 | A second vote by one key at one index for another block is evidence: the key's weight is zero until `detection DAA + ban` (7,200 DAA seconds on devnet), the evidence is carried in blocks and re-detected from blocks | Node-local detection timestamps the ban with the sink's DAA score; a block-carried evidence uses the carrying block's DAA score |
| 3.9 | `getFinalityCheckpoints` reports `finality_active` (the window is full and a lock exists within the last P indices), the latest lock, and since 4 October 2026 `finality_reason` (`active`, `window filling, N of M` with N the sink's DAA score capped at `min_daa` and M `min_daa`, or `paused`) with `window_filled_daa` and `window_full_daa`; the miner prints a `FINALITY` line whenever the reason changes | `last_certified` as a DAA score is not reported; the conflict reason of 3.11 item 4 (two certificates at one index) is not reported (O-3.17), so a conflict still reads as `active` or `paused` |
| 3.11 item 6 (seed source) | The devnet keys the hourly program on the header's own `daa_score` (`epoch_seed`, `docs/review/round-3-2026-10-03.md`, R3.26), not on a checkpoint block | The `seed_source` rule (section 4.3 with the uncertified fallback of 3.11 item 6) is not implemented; nothing on the devnet exercises a seed during a finality pause |
| 3.11 test table | The four-miner test network of the bench-log entry is the only measurement on a real DAG: 93 checkpoints, 0 conflicting certificates, one equivocation strip, one 12-checkpoint pause under the floor, one heal | d = 20, presence 20 indices and a 7,200-s window are devnet values; the measured pause and heal are at those values, not the mainnet ones |

Node state is one persisted blob (`DatabaseStorePrefixes::IgneumFinality`), written at most once a second; votes received over RPC but not yet carried by a block are lost on restart, votes in blocks are not.

## 3.11 Guarantees

Status of this section: Designed, 3 October 2026. Every bound below is derived from Q3 by arithmetic shown in place, and every bound is tied in 3.11.7 to a simulation or a test-network measurement, or marked not yet run. Where this section and 3.3.1 or 3.7 differ, this section is the statement and O-3.16 carries the text fix. "The rule" means W1 to W6, C1 to C5, Q1 to Q4, S1, S2, F1 to F5 and 3.6. The form follows CometBFT's: safety and liveness are stated separately, each with the fraction of weight it assumes and the network condition it needs.

### 3.11.1 The model

- **Voters and weight.** As W1 to W6. At checkpoint index i, `T(i)` is the total weight (every key above dust and not stripped) and `A(i)` the active weight (weight times participation, Q2), both computed at `C_i` from its past. Weight is a property of blocks, not of keys: a key holds exactly the blue blocks in the window that name it, and nothing else changes that number.
- **The adversary.** Controls a set of keys holding together a fraction `a` of `T(i)` at every index considered (`a` is the largest such fraction over the indices in question). Since weight is blocks, holding `a` of total weight means those keys produced `a` of the blue blocks in the 30-day window, whether by the adversary's own hashrate or by purchase (3.11.5). The adversary MAY: sign two different blocks at one index (equivocate); withhold any vote; drop votes, certificates and evidence from the blocks it produces; aggregate as it likes (publish certificates over any subset of valid votes it holds, or none); buy or be given old keys with their history; delay and reorder its own messages; mine privately. It MAY NOT forge a BLS signature or produce blocks without the hashrate of section 1. Its share of active weight is not bounded by `a` alone: an honest view that lacks other honest keys' votes has a smaller `A`, which is why Q3 has two tests.
- **Honest voters.** Follow the rule. They sign the checkpoint on their own selected chain at every index they determine (C1), sign exactly one block per index, carry every vote and certificate they receive (Q2, C3), aggregate what they receive (S1: anyone MAY aggregate), and never select or sign a chain that misses a certified checkpoint they hold (F1). Participation (Q2) is credited to key k at index j only for a vote that names `C_j` as it lies on the selected chain of `C_i`; a vote for any other block earns no participation on that chain (the implementation credits any vote at the index, O-3.19).
- **Network.** Partial synchrony. After an unknown global stabilisation time (GST) every message between honest nodes arrives within a one-way bound `Delta`; before GST messages between honest nodes may be delayed arbitrarily. A partition or an eclipse is a period before GST for the nodes involved. The simulation used `Delta = 2 s` between regions (0.5 and 5 s swept) and the certificate grace of Q4 MUST be at least `3 Delta`. Honest hashrate is a majority of hashrate (a GHOSTDAG assumption, section 2); what finality adds is bounded in weight, not hashrate.
- **Key-set changes.** Dust (W3): a key enters `T` when its window count reaches 100 blue blocks and leaves when it falls below; a key below dust holds no vote. Succession (W5): weight moves once and the old key's later votes are invalid, so a successor pair cannot vote twice. Equivocation stripping (3.6): on inclusion of evidence the key's weight is zero for the rest of the window; stripping lowers `T` and `A` by the same amount and never raises either; two votes by one key at one index are evidence whoever holds the key.
- **Clock.** Every interval is past-median time (Q1), `P = 7,200 s` the presence window, `I = 30` blue score the checkpoint interval, `d` the determination depth (60 placeholder), `G` the grace.

### 3.11.2 Safety

**S.** As long as the adversary holds less than `X` of total weight, the honest nodes never hold two certificates at one index naming different blocks, and never hold a certificate whose checkpoint block is off the chain of a lower certified checkpoint. S does not depend on synchrony: it holds before and after GST.

The arithmetic. A certificate verified at `C_i` in a view `v` has signer weight at least `q_v T` where `q_v = max(2/3 x A_v / T, 17/30)` (Q3). Honest keys sign one block per index, so for two certificates at index i on different blocks, with signer weights `s_1` and `s_2`, the weight that signed both is at least `s_1 + s_2 - T`, and that weight is adversary weight (equivocators). So a conflicting pair needs `a >= 2 q_min - 1` where `q_min` is the smaller binding fraction of the two views:

| Active weight in the weaker view, `A_v / T` | Binding fraction `q_v` | Equivocating weight a pair needs, `X = 2 q_v - 1` |
|---|---|---|
| 1.00 (every honest voter present) | 2/3 | 1/3 = 33.3% |
| 0.95 | 0.633 | 26.7% |
| 0.90 | 0.600 | 20.0% |
| 0.85 or less (the floor binds) | 17/30 = 0.567 | 4/30 = 13.3% |

An honest view has `A_v < T` only when honest votes are missing from its presence window: a partition, an eclipse (3.3.2), or silence. Honest weight `h_out` unreachable from the view for `tau <= P` has participation `1 - tau / P` there, so `A_v / T = 1 - h_out tau / P` (less the uptime shortfall, about 2% in the model). For a partition into two honest parts `h_1` and `h_2` with the adversary reaching both, side j can lock alone once `h_j + a >= s_min(tau)` where `s_min(tau) = max(17/30, 2 (1 - tau/P) / (3 - 2 tau/P))` under the block reading of Q2; the two expressions meet at `tau = 9P/26 = 41.5 min`. Under the cert reading the simulator ran (every key decays during a stall) it is `s_min = max(17/30, 2/3 (1 - tau/P))`, meeting at `tau = 0.15 P = 18 min`, and the time for a side holding `s` to lock alone is `P (1 - 1.5 s)`: 12 min at 60%, 18 min at 56.7%, 0 at 2/3 and above. Both sides over `s_min` is `a >= 2 s_min(tau) - 1`.

So, in words, with the floor at 0.85:

- `X = 1/3` of total weight while every honest voter's vote reaches every honest node within 41 minutes of median time (18 under the simulated reading). This is 3.1's headline: ten days of 100% hashrate, twenty days of 51%, in public.
- `X = 4/30 = 13.3%` of total weight against a partition of the honest network into two parts, each holding at least `17/30 - a` of total weight, unreachable from each other for 41 minutes or longer (18 under the simulated reading), with the adversary reaching both. The eclipse of 3.3.2 is the case where one part is the victim set: F2's 34% attacker with a 20% pool sits at 54% and fails; the same attacker with a 23% pool would not. 4/30 of weight is four days of 100% hashrate or eight days of 51%.
- Between those, `X(tau) = 2 s_min(tau) - 1` falls from 1/3 to 4/30 as the partition lengthens.

The floor sets this trade linearly: with the floor at `f x 2/3` the partition bound is `4f/3 - 1` and the liveness bound of 3.11.3 is `1 - 2f/3` of weight silent. At 0.85 that is 13.3% and 43.3%; at 1 (the total denominator) both are 1/3; every point of liveness past one third costs two points of partition safety (O-3.15). The choice of 0.85 is the project's; this section only states what it buys and what it costs.

The second clause of S (chain of a lower certified checkpoint) follows from the first with F1 and C3. Once an honest node holds a certificate for `C_i` it never selects or signs a chain that misses `C_i`, and after GST every honest node holds every certificate within one block interval plus `Delta` (C3 carriage and gossip). A certificate at `j > i` off `C_i`'s chain therefore needs `q T` of weight that lacks `C_i`'s certificate, which before GST is a side of a partition, and the first clause already bounds any lock that side forms; after GST only the adversary lacks it, and `a < q`. The residual is honest votes for `C_i` in flight across a partition boundary in the `Delta` before the split, which strengthen `C_i`'s certificate and nothing else.

At and above `X`. Two valid certificates can exist at one index, each held by honest nodes. The rule does not resolve the pair (3.11.4) and does not promise to; equivocation evidence strips the keys that signed both for 30 days (3.6), which lowers the adversary's weight but does not undo the pair. At `a >= 2/3` of total the adversary certifies any chain it likes from then on, which takes twenty days of 100% hashrate (3.1) and is a public event; it still cannot make an honest node abandon a certificate it holds (3.11.4).

### 3.11.3 Liveness

**L.** After GST, if honest voters holding at least `Y = 17/30` of total weight are mutually connected within `Delta` and signing, a new checkpoint certifies within `T` of the moment that condition holds, whatever the adversary does within the model, where

`T = D(Y) + I + d + G + Delta`, with `D(Y) = P (1 - Y / (2 (1 - Y)))` for `17/30 <= Y < 2/3` and `D(Y) = 0` for `Y >= 2/3`.

The arithmetic. The floor needs `Y >= 17/30` of total, which no behaviour of the rest can raise or lower (silence leaves `T` unchanged; equivocation lowers it). The active test needs `Y >= 2/3 x A / T`. Keys outside the connected honest set either vote for the honest checkpoint, in which case their weight is in the certificate and the test passes trivially, or do not, in which case 3.11.1's reading of Q2 gives them participation `1 - t/P` after `t` of silence, so `A / T = Y + (1 - Y)(1 - t/P)` and the test passes at `t >= D(Y)`. `I + d` is the wait for the next checkpoint to be determined (one interval plus the determination depth), `G + Delta` the vote round trip and the grace of Q4. Under the cert reading of the simulation `D(Y) = P (1 - 1.5 Y)`, which is shorter; the block reading is the specified one (O-3.18 measures it).

| Honest connected weight `Y` | `D(Y)`, block reading | `D(Y)`, cert reading (simulated) | `T` at `I = 30 s`, `d = 60 s`, `G = 15 s`, `Delta = 2 s` |
|---|---|---|---|
| 2/3 or more | 0 | 0 | 107 s |
| 60% | 30 min | 12 min | 32 min |
| 17/30 = 56.7% | 41.5 min | 18 min | 43 min |
| under 17/30 | finality pauses | finality pauses | no bound |

Why the adversary cannot block L within the model: withholding votes changes nothing above; equivocating strips its weight and lowers `T`; dropping votes from its own blocks delays a vote's entry into the DAG by one honest block, since Q2 needs one block in `C_i`'s past to carry it and honest producers carry every vote they receive; aggregating dishonestly costs nothing because anyone MAY aggregate (S1) and every honest node aggregates the votes it holds; buying keys moves weight between holders and leaves `Y`'s arithmetic as it is.

**When finality pauses.** If the honest voters that are connected and signing hold less than 17/30 of total weight, which with the model's 97.8% resting participation happens once about 42% of weight is silent, no certificate can form until silent keys return or their blocks age out of the window (up to 30 days; a key that keeps mining never ages out). The chain does not stop: blocks, GHOSTDAG ordering (F2 among the tips through the last certified checkpoints) and execution continue on proof of work, every certified checkpoint stays binding, and the node reports `finality_active` false with the reason `paused` (3.9: the exchange guidance for that state is the finality depth in median time). The honest name for this state is "finality temporarily unavailable", and it is the state the test network showed for 12 checkpoints with one voter at 39.6% of total weight (3.11.7). The litepaper sentence that says a silent minority cannot freeze finality is false under the floor and is R3.18's fix.

### 3.11.4 Recovery and what "irreversible" means

**Recovery after a partition, `a < X`.** By S at most one side certified during the partition. At the heal, certificates reach every honest node by C3 carriage and gossip within one block interval plus `Delta`; F1 removes from candidacy every tip whose chain misses them, so every honest node selects the certified side's chain; the other side's blocks since the split merge under the 3,600-s merge-depth bound where they can and are otherwise abandoned, and the transactions in them were never under a certificate (that side's nodes reported `finality_active` false, or their `last_certified` predates the split). The outcome is a deterministic function of the DAG and the certificates, so every honest node reaches the same chain. If neither side certified (a 50/50 honest split), F2 picks the heavier chain and finality resumes within `T` of the heal by L. The simulation checks, in every run of H and I, that every certificate any side held before the heal is in the merged view after it ("every pre-heal lock kept"), and the test network's heal locked 13 pending checkpoints within 30 s with no conflicting certificate (3.11.7).

**No certified checkpoint is ever reversed.** A node MUST NOT delete, downgrade or re-evaluate a certificate it has verified, and MUST NOT report as not final a block it has reported as final. When a node holds two valid certificates at one index (`a >= X`): it keeps following the certificate it verified first under F1, publishes the pair as evidence (C4), sets `finality_active` false with the reason `conflict`, and stops reporting new locks until an operator resolves the split with a configured trusted certificate (F5). The protocol does not pick a winner, because any automatic choice would withdraw a lock some honest node has reported. This is how Kaspa treats a finality conflict: a `FinalityConflict` notification to the operator, no rule that resolves it (`vendor/rusty-kaspa/consensus/notify/src/notification.rs`). This rule replaces the re-evaluation proposal of 3.5 (R3.17; O-3.17).

**To a user.** A block in the past of `last_certified` on a node with `finality_active` true will remain on the chain that node follows, every honest node holding the same certificate agrees, and no weight of hashrate can change that; only an adversary over `X` can produce a conflicting certificate, and even then no honest node withdraws the one it holds. Not covered by this section: that the block's body is available and was validated by the signers (a certificate is a statement about a header chain by voters who validated it; availability and pruning are F3 and section 2); that the block's execution is correct (section 7's proofs); the first month (3.8) and any period with `finality_active` false, where 3.9's proof-of-work guidance applies; and any state the model excludes (3.7 item 8).

### 3.11.5 Acquired old keys against fresh hashrate

Weight is the count of a key's blue blocks in the window (W2), and each block leaves the window 30 days after it was mined whoever holds the key. A key bought with `b` of total window weight therefore carries `b` on the day of purchase and `b (1 - t/30)` on day `t`, while the buyer's own hashrate `r` (as a share of the network) adds `r t/30`. The buyer's share is

`share(t) = b (1 - t/30) + r t/30`,

which moves monotonically from `b` to `r` and never exceeds `max(b, r)`. Buying keys worth `b` is exactly the position of having mined `b` of the network's blocks over the previous 30 days, which is what the sellers did and what the price reflects; it is the same purchase as buying `b` of hashrate for the same period, delivered in advance. To hold the veto (1/3) for a day the buyer needs `max(b, r) > 1/3`; to lock alone it needs 2/3 bought or 2/3 of hashrate for 30 days (3.1). With `r = 30%`: keys worth 20% rise to 30% at day 30 and never reach 1/3; keys worth 40% hold the veto from day 0 and lose it on day 20, then decay to 30%. If the buyer withholds its votes it is scenario C's silent set, with the stall figures of 3.3.1 shrinking as the bought weight decays.

The equivocation strip applies to the key, so it applies to the buyer: one pair of votes at one index by the bought key, from either the buyer or a seller who kept a copy, strips the key for 30 days. A sale that leaves the seller a copy buys a key the seller can destroy at will; the clean transfer is W5 succession, which moves the weight once to the buyer's own key and makes the old key's later votes invalid. Measured in K (3.11.7).

### 3.11.6 Seeds during a pause

The epoch seed (4.3) and the era seed (4.4) are VDF outputs of a checkpoint block at least 1,200 (epoch) or 7,200 (era) DAA seconds before the boundary. If that block had to be certified, a pause longer than the lead would hand every following epoch the same stale checkpoint and the hourly program would stop changing, and a pause at launch under 3.8 would stop it for a month. Rule adopted from O-4.3, 3 October 2026: the seed checkpoint `C(e)` is the selected-chain block at the checkpoint blue score the lead rule names, on the header's own selected chain, certified or not. Every header names it by `seed_source` and is valid only if that block is on its own selected chain at the blue score of index `i(C(e))` (4.3 step 4), so the choice is a function of the header's past and two nodes validating one header derive one program. Mining therefore never waits for a certificate: the program changes every hour through any pause, including the first month.

What a later certification does. If the certificate for index `i(C(e))` names the block the headers named, nothing changes. If it names another block, every header that named the losing block lies on a chain that misses a certified checkpoint, and that chain is already discarded by F1 and C3; no header on the certified chain ever named the losing block, because `seed_source` must lie on the header's own selected chain. A certificate can never land on a block other than the one at blue score `30 i` of the certified chain (C1), so a later certification confirms the seed the certified chain used or discards a branch the fork rule has already discarded; it never changes the program of any block on the certified chain. The lead of 1,200 DAA seconds plus `d` makes a reorg across the seed block a reorg of at least 20 minutes of the selected chain, which the finality depth bounds (3.9), not merge depth. Not yet exercised on the devnet (O-4.3, implementation pending).

### 3.11.7 Test table

Each guarantee, the scenario that tests it, and the measured result. Bench-log citations are to `docs/bench-log.md`, entry "igneum-node devnet v2" (3 October 2026), by its paragraph; `sim/results_v2.md` by section letter.

| Guarantee | Scenario | Measured |
|---|---|---|
| Weight equals blocks and tracks hashrate (3.11.1) | results A, 60 days; test network checkpoint 4 | corr(hash, weight) 1.00000, weight:hash 0.82 to 1.12 (A); weights 34 + 31 + 30 + 24 blocks for four miners, total 119 (bench-log "Key reveal") |
| S, connected network, `a < 1/3` | results A (no attacker, 60 days); test network, four miners, 53 minutes | 0 conflicting locks in 172,883 checkpoints (A); 93 checkpoints, every one locked on all three nodes, 0 conflicting certificates, identical hashes and weights at every RPC sample (bench-log "Checkpoints and locks") |
| S under an honest partition, `a = 0` | results E, floor rows, 50/50, 60/40, 67/33, 80/20, 33/33/34 for 360 min with retarget; results I, 40/40/20 | 0 conflicts in every split (E); 40/40/20 honest three-way split: 0 conflicts and 0 locks on any side for 150 and 360 min (finality paused on all three), first lock 0 min after the heal, five seeds (I) |
| S under a partition with an equivocator below 4/30 | results H, 50/50 honest, attacker 10% and 13%, 150 and 360 min, five seeds | 0 conflicting locks and no lock on either side at 10% and 13% for 150 and 360 min in every seed (H); 13% is the knife edge, each side holding 56.5% against the 56.7% floor |
| S fails at and above 4/30 under a partition (the bound) | results H, attacker 14%, 20%, 34%; results I, 40/40 plus a 20% equivocator | 14% (each side 57.0%): conflicts in 2 of 5 seeds at 150 min and 4 of 5 at 360 min, first at 48 to 284 min, the model's 2% uptime shortfall deciding; 20% (60.0%): 256 to 276 conflicts in 150 min and 658 to 692 in 360, first at 12 to 16 min against 12 predicted; 34% (67.0%): first conflict at 0 to 1 min (H); 40/40 plus a 20% equivocator reaching both: 256 to 276 conflicts in 150 min, first at 12 to 16 min; the same 20% against a 40/40/20 honest split (sides 52/52/36 of total) gives 0 (I) |
| S under an eclipse | results F2, 34% attacker plus a 20% pool (54% side), 1, 2, 4 h | 0 conflicting locks at every length (F2) |
| L at `Y >= 2/3`: `T = 107 s` | results A lock latency; test network steady state | median 2.5 s, p99 4.6 s after the checkpoint block at `Delta = 2 s` (A); determination to lock median 0.80 s, p90 1.08 s, max 1.55 s (bench-log "Checkpoints and locks") |
| L at `17/30 <= Y < 2/3` | results C, 40% silent; results J, 34% and 40% silent for 1, 6, 24 h; test network phase A, one of three miners stopped | 13 min to the first lock, 138 intermittent stalls in 3 days (C, cert reading); 34% silent: first lock 0 to 2 min, 98 to 100% of checkpoints locked, longest gap 1 to 15 min over 24 h; 40% silent: first lock 11 to 13 min, 78 to 99% locked, longest gap 11 to 47 min (J, cert reading); locks continued with 33% silent (bench-log "Partition test", phase A) |
| Pause below the floor, chain continues | results C, 45% silent; results J, 45% silent for 1, 6, 24 h; test network phase B, one voter alone | never locks while silent (C); 45% silent: no lock for the whole 1, 6 and 24 h, longest gap 60, 360 and 1,440 min, 0 conflicts (J); 0 locks in 12 checkpoints with 39.6% of total and 72.3% of active, the floor alone holding, `finality_active` reporting the pause (bench-log "Partition test", phase B) |
| Resume after the pause within `T` | results J, after the silent set resumes; test network phase C | first lock 0 min after the silent set resumes at every weight and length, 0 stalls in the 3 h after (J); checkpoints 73 to 85 locked within 30 s of the restart, 86 to 92 at the steady cadence (bench-log phase C) |
| Deterministic heal, no lock reversed | results H and I, every pre-heal certificate present after the heal; results E post-heal stalls; test network heal | every pre-heal certificate present after the heal in all 60 runs of H and 40 of I, 0 post-heal stalls (H, I); 0 post-heal stalls in every E run; no conflicting certificate and no stall on any node through the heal (bench-log phase C) |
| Equivocation strips the key, locks continue | test network, miner m4 with `--equivocate` from index 43; results E and F, strip at the heal | stripped on every node at index 43, voter list 3, locks at 3 of 3 votes from index 44 (bench-log "Equivocation"); post-heal stalls 0 with the attacker stripped (E) |
| Weight ages out: churn | results D, 35% and 50% stop mining and signing | first lock 2 min at 35%, 4.1 days at 50% (D, floor 0.85) |
| Acquired keys decay as the window moves (3.11.5) | results K, keys worth 20% and 40% bought, 30% hashrate, signing and silent, 30 days, five seeds | share follows b (1 - t/30) + 0.3 t/30 within 0.6 points at every sampled day in every seed; keys worth 20% rise to 30% on day 30 and never reach 1/3; keys worth 40% hold the veto from day 1 to day 19 or 20 (formula 20) and end at 30%; withholding its votes, the 40% buyer stalls 305 to 1,085 of 86,400 checkpoints in 30 days (79 to 186 on day 1, 0 to 50 on day 30) and the 20% buyer 0 to 318; 0 conflicts (K) |
| Signing stops while mining continues, 1, 6, 24 h | results J | stalls while silent 0 to 31 (34%), 23 to 123 (40%), every checkpoint (45%); first lock after resume 0 min; 0 conflicts (J) |
| Seeds during a pause (3.11.6) | devnet epoch boundary through a forced pause | not yet run (O-4.3 implementation) |
| Two certificates at one index: no lock withdrawn (3.11.4) | devnet with a forced double certificate | not yet run (O-3.17) |
| `T` under the block reading (3.11.3) | O-3.3 re-run | not yet run (O-3.18) |
| Participation credited only for the chain's checkpoint (3.11.1) | results C with an adversary voting for private blocks | not yet run (O-3.19) |
| The first month (3.8) | launch-month simulation | not yet run (O-3.1) |