aboutsummaryrefslogtreecommitdiffstats
path: root/docs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-16 10:38:37 +0000
committertv <tv@krebsco.de>2026-11-16 10:38:37 +0000
commit02cca7a1de374c17caab972afa4dbed923335d7b (patch)
treee83100e376a29265acda0c28fa3f3b5e888773ba /docs
parente44cd86fb02c0c0dd1177e9dc9d7dc35b3efbe02 (diff)
federation: two `true`s voting twice only where neither proposal is dead
A party's `true` on two proposals of one version was voting twice where both passed, or neither was dead by all the votes. But a party's `true` and `false` on one proposal both count, so one proposal can be passed and dead at once: another party's late `true` beside its `false` made every party that went on to the second proposal, once the first was dead, look as if it had voted twice. Two `true`s are voting twice only where neither proposal is dead by all the votes. A death is never taken back, so an honest party's first proposal is always dead by all of them; and where two versions changing one were written, the party whose `true` and `false` made a proposal passed and dead is named. "Why it holds" says the same.
Diffstat (limited to 'docs')
-rw-r--r--docs/federation.md25
1 files changed, 14 insertions, 11 deletions
diff --git a/docs/federation.md b/docs/federation.md
index 4748a49..cbe48b4 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -311,10 +311,12 @@ which a remake leaves out (Remakes).
twice, or with its keys named anew (Forks).
* **A party that voted twice shows** in the votes alone, both signed with keys their
version names for it: its `true` and `false` on one proposal, or its `true` on two
- proposals of one version where both passed, or neither is dead by all the votes cast.
- Where a vote was committed, and how often, changes none of it, and two envelopes of
- one value at one vote's place are one vote; an honest party backs another proposal
- only once the first is dead. A tool over the votes the parties' clients keep reports
+ proposals of one version where neither is dead by all the votes cast. Where a vote was
+ committed, and how often, changes none of it, and two envelopes of one value at one
+ vote's place are one vote; an honest party backs another proposal only once the first
+ is dead, and a death is never taken back. Two versions changing one still name a
+ party: where one of the proposals is passed and dead by all the votes, the party whose
+ `true` and `false` made it so. A tool over the votes the parties' clients keep reports
it, as they are signed and anyone can check them, after a remake left them out too; a
node reports the versions it refused. That proves its keys signed both, not that it
meant to: two of its nodes voting each by itself, or a stolen key, look the same.
@@ -597,16 +599,16 @@ long nodes stay together.
to places. A copy of an older envelope is behind; a new one written at a history from
before a version is behind what is written under it.
2. **The policy.** A version is written only where, at one history, two thirds of the
- parties of the version it changes voted `true` for it, and a node takes it only
- where it changes the version the node reads. An honest party backs one proposal on a
+ parties of the version it changes voted `true` for it, and a node takes it only where
+ it changes the version the node reads. An honest party backs one proposal on a
version at a time, and another only once the first is dead; its votes count as cast.
So a proposal can't pass at one history and be dead at another unless some party's
`true` and `false` for it are both there, and two proposals on one version pass only
- where some party backed both while neither was dead. Without keys voting twice, at
- most one version changes a version, and every node takes it; keys an earlier version
- named move no node that took the version after it. With them, each node keeps the
- version it took, nodes holding the same changes still read the same policy, and the
- parties fork.
+ where some party backed both while neither was dead, or some party's `true` and
+ `false` on one of them are both there. Without keys voting twice, at most one version
+ changes a version, and every node takes it; keys an earlier version named move no
+ node that took the version after it. With them, each node keeps the version it took,
+ nodes holding the same changes still read the same policy, and the parties fork.
3. **Remakes.** A node follows a remake only where it built the snapshot itself, from a
base it holds, a member there, the version it reads written there; its peers' word
never moves it. What came after, under that version, is replayed in history's order,
@@ -704,6 +706,7 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang
| 77 | A party's vote committed again at a history before the nays that freed it, its clock set between, then a remake | The replay refuses it at first, and takes it once the rest is in | unit |
| 78 | A listed node starting a fresh writer with every change | Refused past the bound on the writers a node starts in an epoch | unit |
| 79 | Keys voting twice, or a writer forked, part honest nodes | An operator has its node drop what it took and take the other side's; no fork | sim |
+| 80 | An honest party backs a second proposal once its first is dead; another party later signs `true` on the first too | It isn't named: its first proposal is dead by all the votes; the party with `true` and `false` on one is | unit |
## Roads not taken