From e5f8df2a78f26d5928d1c96573dae5620dba5e25 Mon Sep 17 00:00:00 2001 From: tv Date: Thu, 19 Nov 2026 01:48:58 +0000 Subject: docs: quiet parties, proof of voting twice, the next change keeping the number From the red-team review of the design: * a party that never votes holds those backing a proposal short by as many votes: they can neither pass it nor back another, a compromise all others would pass among them; `federation.md` draws that out, and the promises guide says so; * a client keeps its own votes and the nays that freed it, not another party's two: where keys voted twice, whoever saw it keeps the votes naming the party before a checkpoint leaves them out; * nothing but agreement keeps a party from using a change that keeps the federation's number before every node runs it: the next such change names itself in the version, so that two thirds decide when, and a node not running it stops at that version. --- docs/federation.md | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) (limited to 'docs/federation.md') diff --git a/docs/federation.md b/docs/federation.md index ceb1064..a547026 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -297,6 +297,13 @@ The five back nothing else on this version, and the others take X or fork. A pro that could pass at one history and be taken back at another would let two versions be written without anyone voting twice. +So a party that doesn't vote counts as much as one that does: the two quiet ones hold the +five backing X, who can't back a compromise the seven others would all pass until X passes +or dies, and silence never ends. With q parties quiet, a proposal short by q votes or +fewer can neither pass nor die. A party gone quiet for good is taken out by a version +while two thirds still answer, and a party's client says when a `true` would bind its +party unless every party yet to vote votes `false`. + Once a proposal passed on the current version, a node writes it as soon as it holds it passed, by a **version** event, `{"deps": […], "version": }`, which no party signs: any node may write it, and the same version written by several is one (below). @@ -481,11 +488,14 @@ version as every node does. What a checkpoint loses: what counted no more before it, so that a key added back, or a place given back, brings back nothing signed before it, and a party that voted twice on -a version behind it shows only in the votes its clients kept; and what isn't above its -heads, which its party signs again. Few are: the heads are ones its proposer held for a -while, no voter backs heads that leave out what it held for a while, nodes build on them -while the vote takes its course, a client writing once a checkpoint is proposed builds -only on what is above its heads, and a party's client signs again what a move refused. +a version behind it shows only in the votes kept outside the store: a client keeps its +own votes and the nays that freed it, not another party's two, so where keys voted twice, +whoever saw it keeps the votes naming the party (`GET /events/{id}`) before a checkpoint +leaves them out; and what isn't above its heads, which its party signs again. Few are: the +heads are ones its proposer held for a while, no voter backs heads that leave out what it +held for a while, nodes build on them while the vote takes its course, a client writing +once a checkpoint is proposed builds only on what is above its heads, and a party's client +signs again what a move refused. **Joining.** Once a checkpoint passed, a node joins from a checkpoint its operator pins, not from the root ([`store.md`](store.md), @@ -852,7 +862,11 @@ otherwise, keeps the number: the keys of type `ecdsa-sha2-nistp256` taken beside ones are such a change. It is rolled out first and used after: every node runs a continuum that takes it before any party uses it. A node that doesn't refuses what uses it, and reads otherwise than the others until it does; at a version naming such a key, -which it doesn't read, it stops, as above. +which it doesn't read, it stops, as above. So that no party picks the moment nodes part, +the next such change names itself in the version, by a field that only a version using +it gives: a continuum that takes it takes what it adds only under a version naming it, +which two thirds pass, and a node running one that doesn't stops at that version rather +than refusing what follows. ## The registry on it -- cgit v1.3.1