diff options
Diffstat (limited to 'docs')
| -rw-r--r-- | docs/federation.md | 252 |
1 files changed, 154 insertions, 98 deletions
diff --git a/docs/federation.md b/docs/federation.md index 9d43411..6099caf 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -50,14 +50,14 @@ that nothing coming from any node breaks a promise for the others. ## What is promised 1. **What counts is what a party signed, with a key it holds, where the policy lets it - write.** Every honest node that holds the swarm from its genesis change refuses - what the version current at a change's history doesn't let be written, whoever - sends it, and reads nothing else as counting. + write.** Every honest node that holds the swarm from its genesis change, or + followed every remake since, checking each, refuses what the version current at a + change's history doesn't let be written, whoever sends it, and reads nothing else as + counting. 2. **The policy changes only by the votes of a share of its parties**, two thirds unless they decide otherwise, as one history saw their votes; and nodes that hold the same changes read the same policy. Without a party voting twice, a version that - passed stays; with one, the parties' nodes agree again once they sync (Changing the - policy). + passed stays; with one, the parties fork without it (Changing the policy). 3. **Any group carries on as it chooses.** Its parties fork with the policy they want, and whoever wants to follow does. Nobody is held by parties it doesn't follow. @@ -75,7 +75,8 @@ Not promised: still commit or sign at a history from before: only a version ends what a key signs (Keys), and a remake ends what is written at the time before it; * anything to a node that joins, or comes back after a remake without holding the - epoch before: it takes the document on its peers' word (Remakes). + epoch before: it takes the document on its peers' word (Remakes); +* that what nodes read stays put after a party voted twice, until the parties fork. ## The design @@ -84,11 +85,12 @@ envelope its party signs, `cv2.<value>.<meta>.<signature>`, read the one way eve of continuum reads it *(checked: `document::signed`)*. The meta names the swarm, the path, who signed, when, the envelope it replaces (`prev`) and its number there (`seq`, one more than that one's). Under the federation it names also the **version** of the -policy current where it was written, by number (`version`, The policy): a change -writing one that names another is refused. Of the envelopes a place holds, written at -once, the one with the highest version number is its value, then the highest `seq`, -then the lower SHA-256. So what a place holds is its party's to say, never the order -of operations, which whoever writes a change steers; and what was signed under a later +policy current where it was written, by number (`version`, The policy): a change writing +one that names another is refused, but for an epoch's first change (a remake's snapshot, +a fork's genesis), which is judged by none. Of the envelopes a place holds, written at +once, the one with the highest version number is its value, then the highest `seq`, then +the lower SHA-256. So what a place holds is its party's to say, never the order of +operations, which whoever writes a change steers; and what was signed under a later version is ahead of anything written at a history from before it. A swarm under a strict policy reads by `seq` alone, the same way, and replays a value @@ -116,7 +118,7 @@ worth knowing (Where Automerge sets limits). A federated swarm's `_continuum/access/policy` is `{"version": 2, "federated": true}`. What the policy says is in its **versions**, a chain: each is a string of JSON, named by the SHA-256 of its bytes, numbered, and naming the version it changes (none for -the first, number 0): +the first, number 0, which only the federating change writes; a fork's first, Forks): ```json { "federation": 1, "number": 7, "changes": "<hash of the version it changes>", @@ -124,9 +126,9 @@ the first, number 0): "parties": ["tv", "lass", "makefu"], "keys": { "makefu": ["ssh-ed25519 AAAA… makefu"] }, "rules": [ + { "path": "names/r/wiki/@", "writer": "lass" }, { "path": "home/{party}/**", "writer": "{party}" }, { "path": "names/r/{party}/**", "writer": "{party}" }, - { "path": "names/r/wiki/@", "writer": "lass" }, { "path": "ip4/10/243/7/*", "writer": "tv" }, { "path": "names/**", "writer": false } ] } ``` @@ -151,7 +153,9 @@ written within one, and a path that holds places is no place. How names and addr are spelled as paths is the application's: the registry writes a name by its labels, last first, its own value at `@` (`names/r/tv/toaster/@` for `toaster.tv.r`, `names/r/tv/@` for `tv.r`), and an address by its parts, so that a party's zone or -block is one rule. +block is one rule. Rules go by first match, so a party named like a shared name takes +it where a `{party}` rule comes before it: the application keeps party names apart +from its spelling (no party named `@`, nor `wiki` while `wiki.r` is lass's). A version is none if it doesn't read as one (JSON with a key twice, fields missing or more), its bytes don't hash to its place, or it breaks any of the above: it can't @@ -171,7 +175,7 @@ version. What a party writes is an envelope, signed by one of its keys. A version, and the keys a version sets, are written unsigned, and count by the votes the version had. A -proposal's place takes only the proposal, or its party's `null`. Of continuum's own +proposal's place takes only the proposal. Of continuum's own data, a federated swarm keeps what nodes write for the protocol (member entries, remakes and their acks, epochs), written by members as in every swarm; a member's change carries its node's signature, as signatures are required in a strict swarm. It @@ -204,36 +208,41 @@ changes, and the proposal, by their hashes. No vote there is no vote. Once a proposal passed on the current version, any member writes it at `_continuum/federation/versions/<hash>`, as it is, unsigned, with the keys it sets -(Keys); every node judges that change by the votes in its history, and by the version -it changes being current there. A version takes effect when it is written, and judges -every change in sight of it. +(Keys); every node judges that change by its history: the proposal written there, the +votes it had, and the version it changes current. A version takes effect when it is +written, and judges every change in sight of it. -**The current version** is the end of the longest chain of written versions from the -first, each changing the one before. Of chains of one length, the one with the lower -hash where they part. +**The current version** is the written version with the highest number; of two with +one number, the lower hash. A number is checked where its version is written, so the +highest is the end of the chain, read from what the document holds without the +versions behind it, which may go (What counts). * **Votes that split pass nothing**, like a proposal that gets only nays: three for - one proposal and three for another, of six. Those who didn't back a proposal vote - `false` on it; once it is dead, its backers are free, and another proposal can pass - on the same version. Parties that won't wait fork. -* **Two versions changing one version** are written only if a party voted twice: - `true` and `false` on one proposal, each shown to some, or `true` on two; one party - is enough where a vote is close. The nodes that read each side for a while agree once - they sync: the side the parties went on with is the longer, and if neither went on - yet, the lower hash. What was written under the other side stays written, and counts - as the current version says. A version written late beside one the parties went on - from is shorter, and stays so: making it longer takes votes on proposals made on it, - and honest parties vote only on what they read as current. + one proposal and three for another, of six. Nays end it: once a proposal is dead, + its backers are free, and another proposal can pass on the same version. Parties + that won't wait fork. +* **Two versions with one number** are written only if a party voted twice: `true` and + `false` on one proposal, each shown to some, or `true` on two; one party is enough + where a vote is close. Nodes that hold both read the one with the lower hash, so + they agree once they sync, and where nothing was built on the other, that settles + it. Where both were built on before the sides met, what nodes read can change again + while votes cast on the other side before then come in: each is taken where it was + cast, as every vote is. And what was written under the version not read ranks with + what was written under the other, both naming one number: a key set a thief writes + there is ahead of the one the other version set. So the parties answer a double + vote by forking without the party that voted twice, the fork's version setting + every party's keys (Forks). What the side not read deleted as housekeeping, and + counts by the version read, its party's client puts back. * **A party that voted twice shows**: its two votes on one version, both signed with - its keys. A node that holds them, or two versions changing one, reports it (a log, - the API), with both votes; a client keeps them, as they are signed and anyone can - check them after the document has dropped them. 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. Taking it out is a version, the parties' choice. + its keys, each taken where it was cast. A node reports it (a log, the API), with both + votes, from the history: a place holding two votes counts by its read like any + place, and two `true`s are voting twice only where neither proposal was dead at the + other's history. A client keeps the votes, as they are signed and anyone can check + them after the document has dropped them. 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. + Taking it out is the parties' choice, and a fork. * **A proposal on a version that isn't current lapses**, with the votes on that - version. Its party proposes it again on the current one. -* **Who proposed doesn't matter** once it is written: a proposal passes whether its - party is still one or not. + version. Everything the federation decides is a change of the policy: who the parties are, and their keys where they lost them; who writes where, which is giving an identifier, @@ -244,8 +253,11 @@ naming another (Changing the federation). A party's keys are at `_continuum/federation/keys/<party>`: one envelope, the set, signed with a key of the set it replaces, numbered as any envelope. The change that -writes a version setting a party's keys writes them there too, unsigned, with the -version's hash: they are ahead of every set written under an earlier version. +writes a version setting a party's keys writes them there too, and only that change: +an envelope without a signature (`cv2.<value>.<meta>.`), the keys the version sets and +no others, its meta naming that version, `prev` and `seq` as any envelope's. It is +ahead of every set written under an earlier version, and the party's next set names it +as the one it replaces. * **A value counts only while the key that signed it is among its party's keys**, votes excepted, which count as cast. Changing keys is: write the new set, and sign @@ -273,11 +285,14 @@ whole. These count no more, and nothing else is stale: longer one, its keys and its node list; 2. a value signed by a key that isn't among its party's, votes excepted; 3. a proposal on a version that isn't current, and the votes on that version; -4. a version not on the chain to the current one, or behind it; +4. a version behind the current one: of a lower number, or of its number with the + higher hash; 5. an envelope behind another at its place; 6. the member entry of a node no party lists; 7. a value written before the swarm was federated, unless a party's key signed it and - the first version lets that party write there. + the first version lets that party write there; +8. a party's `null` where everything its place ever held, as the deleting change's + history has it, was signed by keys its party no longer holds. **Any member may delete what counts no more**, place by place, never a map holding places; every node judges the deletion by the document the deleting change makes. That @@ -287,19 +302,24 @@ it in the same change; others delete only what they find stale, as in a swarm wh parties went quiet. **What is deleted can be put back** where its place is empty, by anyone who holds it, -and counts if its key is among its party's and its party may write there: a place -taken from a party and given back may show what the party had there. Whatever the -party writes there under a later version is ahead of it. +at a history where the version it names is current, and counts if its key is among its +party's and its party may write there: a place taken from a party and given back may +show what the party had there. Whatever the party writes there under a later version +is ahead of it. So a party's `null` stays while what it covers could come back and +count: it goes once that was all signed by keys its party dropped (8, above), or at a +remake (Remakes). Neither happens by itself; either can, so that a swarm that never +remakes can be kept from growing with every name ever deleted. ### Nodes A party lists the nodes that carry for it, by node ID, at -`_continuum/federation/nodes/<party>`; a node listed by two parties carries for -neither. Only a listed node is a member: it registers, commits changes and syncs, and -nodes sync with members only (Stages). A node commits whatever envelopes it is given, -its party's and others' alike: what counts is who signed a value, not which node -committed it. So a party without nodes of its own writes through any node that takes -its envelopes. +`_continuum/federation/nodes/<party>`. Only a listed node is a member: it registers, +commits changes and syncs, and nodes sync with members only (Stages). A node's party is +its operator's, in its configuration, and it takes tokens only from the nodes its party +lists; another party listing it changes nothing for either. A node commits whatever +envelopes it is given, its party's and others' alike: what counts is who signed a value, +not which node committed it. So a party without nodes of its own writes through any node +that takes its envelopes. ### Forks @@ -309,19 +329,22 @@ the group won't follow passed, the parties can't agree, or it leaves the federat 1. One of the group starts the new swarm. Its genesis change holds what the old document read as at heads it names, as a remake's snapshot does, but for the - federation's versions and continuum's member entries: of versions, only the - group's own, written as the fork's first, numbered one past the highest at those - heads, setting every party's keys. Every proposal is a chance to fork: the - version is usually one that didn't pass. To leave the federation, the genesis holds - another policy instead, and what it needs. -2. A swarm is named by its genesis change's hash, which nobody chooses, and an - envelope's meta names it so. The genesis change holds envelopes signed for the swarm - it came from, and they count; beyond them, nothing signed for one swarm is taken in - another. + federation's versions, the keys they set, continuum's member entries and the swarm's + name: of versions, only the group's own, the fork's first. It names the highest + version at those heads as the one it changes, is numbered one past it, and sets + every party's keys; judged by none, as an epoch's first change is. Every proposal is + a chance to fork: the version is usually one that didn't pass. To leave the + federation, the genesis holds another policy instead, and what it needs. +2. A fork is named by its genesis change's hash, which nobody chooses: the first change + after it, by any member, writes it at `_continuum/swarm`, as every node checks, and + remakes carry it like any value. An envelope's meta names it. The genesis change + holds envelopes as the old document read them, and they count, whatever swarm they + name; beyond them, nothing signed for one swarm is taken in another. 3. The others join it as a node joins any swarm, by its genesis change's hash. A node that holds the old document checks the new one against it first, the same at those - heads but for the versions and member entries, and says what it holds that those - heads lack. + heads but for what step 1 leaves out; says what it holds that those heads lack; and + says, party by party, whether the fork's version gives it the keys it had there: a + founder may give a party that didn't go keys of its own. A fork needs nobody's vote and nobody's ack: it binds only those who go, and the swarm they left goes on for those who stay. A party the fork's version leaves out writes @@ -335,7 +358,7 @@ What a party's nodes do of themselves is their operators' business, written nowh join a fork where parties their operator follows went, vote as those voted, vote by bounds their operator set, or do nothing without their operator. So a federation that cooperates can have a group that leads without being named: the active parties the -others follow. A party votes from one node only, so that it never votes twice. +others follow. ### Shared identifiers @@ -357,9 +380,12 @@ version, by one who may write the policy. From then on a change is taken only if change is in its history, or it is in that change's history; any other is refused, received or held, and a node that held one beside it drops it, with what builds on it, once a peer tells it so. It is continuum's rule for a swarm turned strict -*(checked: `access::rules`, `before_strict`)*, read for the federating change. Of two -federating changes written at once, the one with the lower hash. A swarm federated -from its genesis change has no time before. +*(checked: `access::rules`, `before_strict`)*, read for the federating change: the one +the writes of the policy lead back to. One written beside it, federating too, is +refused like any other, so a change made later to look as old can't take its place; +two at once split the nodes that took one from those that took the other, and the +parties fork from one. Nothing writes the policy's place after it: the federation +changes by versions. A swarm federated from its genesis change has no time before. What was written before counts only where a party's key signed it and the first version lets that party write there: the parties sign again what they keep. An @@ -378,14 +404,26 @@ is continuum's as in every swarm. What a federated node asks of a remake: * **Writes after the base** are replayed as the policy shapes them, as continuum replays under a strict policy: at each place, the chain of envelopes that leads from what the new document holds there to what the old one reads, each in a change of its own, - judged again in the new epoch. Versions written after the base are replayed with - them, in the order they were written, each judged by the votes as when it was - written. What the new epoch refuses (its key was dropped by a version, its place - given to another) goes to the quarantine of the node that holds it, and its party - signs it again if it still may. Housekeeping after the base isn't replayed: what it - deleted is stale again, and is deleted again. + judged again in the new epoch, each after those its change builds on, clocks only + between changes neither of which saw the other *(checked: `remake::delta`)*. Versions + written after the base are replayed with them, and whatever names a version before + the next, each judged by the votes replayed before it. Whether a place is held + already goes by version number, then `seq`. What the new epoch refuses (its key was + dropped by a version, its place given to another) goes to the quarantine of the + node that holds it, and its party signs it again if it still may. +* **Housekeeping after the base** isn't replayed: what it deleted is stale again, and + is deleted again. But where a chain starts on an empty place (`prev` empty) and what + the new document holds there counts no more by the versions replayed so far, the + replaying node deletes that in the first link's own change, judged by the document + that change makes, as housekeeping is. +* **A party's `null`** may be left out of the snapshot once a version later than the + one it names is current: nothing naming an earlier one can be written in the new + epoch, and an empty place reads as one holding `null` does. -So a remake decides nothing that counts, and a swarm that never remakes stays as +So a remake decides nothing that counts, but what it can't hold: of two envelopes of +one version and `seq` at a place at the base, the snapshot keeps one, and a write after +the base on the other, or an envelope put back after it on one the snapshot lacks, goes +to the quarantine, and its party writes again. A swarm that never remakes stays as correct as one that remakes all the time; it only grows slower. A remake does end one thing: nothing is written at a history from before it, so what a dropped key or a node taken off its list could still write there ends with it. @@ -420,8 +458,8 @@ Recommendations, not rules: none of these breaks a promise, only how fast a node version current there, which the versions written in that history fix, each judged by the votes in its own. Every node judges alike, and refuses the change and everything built on it. What counts is read from what the document holds: the - current version, the end of the longest chain; each party's keys, by that version - and its set; each place's value, by version number, then `seq`. None of it depends + current version, the highest number; each party's keys, by that version and its + set; each place's value, by version number, then `seq`. None of it depends on the order of operations. 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, the share of the @@ -430,7 +468,7 @@ Recommendations, not rules: none of these breaks a promise, only how fast a node 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. Without a party voting twice, at most one version changes a version. With one, nodes still read the same - version once they hold the same changes: the longest chain. + version once they hold the same changes, and the parties fork. 3. **Carrying on.** A fork is a swarm of its own, named by its genesis change, joined by its operators' choice only. A party nobody follows carries on alone. @@ -450,7 +488,7 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 7 | A version written without the votes, or not changing the current one at its history | Refused at its history | unit | | 8 | A version that doesn't read, has a key twice, a share of a half, a rule under `_continuum` or without a literal first segment | No version: can't pass, refused when written | unit | | 9 | `true` on two proposals of one version | The second refused, unless the first is dead at its history | unit | -| 10 | `true` on two proposals at once, from two nodes | Both taken; two versions may be written; the longest chain is read; reported | unit, every order | +| 10 | `true` on two proposals at once, from two nodes | Both taken; two versions of one number may be written; the lower hash is read; reported; the parties fork | unit, every order | | 11 | `true` and `false` on one proposal at once | Both held; a node that saw only one may write a version. As 10 | unit, every order | | 12 | A vote changed, or deleted while its version is current | Refused | unit | | 13 | A vote cast at a history from before, on a proposal made since | Refused: its proposal isn't written there | unit | @@ -458,9 +496,9 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 15 | Votes split, honestly or not | Nothing passes; nays make the proposals dead, and another passes | unit | | 16 | The parties beyond the share never vote, or vote `false` on everything | Nothing passes; the others fork | sim | | 17 | The party a version takes out writes that version itself | Written: a version counts by its votes, not its writer | unit | -| 18 | A version written late beside one the parties went on from | Shorter: changes nothing | unit | -| 19 | A proposer grinds its version's hash | Wins a tie of two versions, one number, nothing built on either; only with a double vote | unit | -| 20 | Values signed with a stolen key | Count until a version drops the key, then none of them | unit | +| 18 | A version written late beside one the parties went on from | A lower number: changes nothing | unit | +| 19 | A proposer grinds its version's hash | Wins a tie of two versions of one number; only with a double vote, which a fork answers | unit | +| 20 | Values signed with a stolen key | Count until a version drops the key, then none of them; under a version sharing its number with another, until a fork | unit | | 21 | A deleted value put back where its place is empty | Counts if its key and its place are still its party's; behind whatever the party writes there later | unit | | 22 | A write in another party's namespace, or at an identifier of another's | Refused by the rule | unit | | 23 | Housekeeping of something that counts | Refused, by the document the change makes | unit | @@ -470,7 +508,7 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 27 | A change written at once with the federating change | As 26, on every node alike | sim | | 28 | A remake whose document reads otherwise than the base | Nodes holding the base stay, and never rejoin it | sim | | 29 | Two envelopes at one place beyond a remake's base | The chain to the one read is replayed | unit | -| 30 | A version written after a remake's base | Replayed with the envelopes, in order | unit | +| 30 | A version written after a remake's base, an envelope written beside it | Replayed, the envelope first, as it names the version before | unit | | 31 | A joining node handed a made-up epoch | Taken. Not promised | sim | | 32 | The party with most nodes remakes often, or never acks | Slow, not wrong; the others fork | sim | | 33 | A writer forked: two changes, one number | Honest nodes split until a remake, or a fork. Not promised | sim | @@ -478,11 +516,20 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 35 | A party withholding its changes or votes | Not promised | — | | 36 | Flooding: namespace, proposals, history, writers | Slow, not wrong | bench | | 37 | A node taken off its list writes changes at a history where it was on | Taken where valid there; behind what is written under later versions | unit | -| 38 | A token from another party's node | Refused | unit | +| 38 | A token from another party's node | Refused: a node's party is its configuration's | unit | | 39 | Envelopes the stayers sign after a fork, brought to the fork | Refused: signed for the other swarm | unit | | 40 | A fork whose genesis change differs from the document it names | Nodes holding that document don't join, and say what differs | sim | | 41 | A fork at heads of its founder's choosing | Joiners holding the document are told what those heads lack | sim | | 42 | A federation, or a policy, a node doesn't know | It stops taking changes | unit | +| 43 | A party lists another party's nodes | Nothing changes for either | unit | +| 44 | The versions behind the current one deleted | The current one is still the highest number | unit | +| 45 | A vote cast on the side not read, before the sides met, sent after | That side may gain a version, and be read. Not promised: the parties fork | unit | +| 46 | A key set written under the version not read, of two with one number | Ahead of the set the other wrote, until a fork | unit | +| 47 | A place given to another and emptied after a base, its new holder writing after that | Replay deletes what counts no more there, then writes the new holder's chain | unit | +| 48 | Two envelopes of one version and `seq` at a base, a write after it on the one not kept | Quarantined; its party writes again | unit | +| 49 | A federating change made later to look as old | Refused: beside the one the policy leads back to | unit | +| 50 | A `null` deleted while what it covers could still count | Refused, by the deleting change's history | unit | +| 51 | A fork's version giving a party that didn't go keys of its founder's | Joiners holding the document are told, party by party | sim | ## Roads not taken @@ -497,14 +544,19 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang * **One vote per version**, never to be cast again. It bounds what parties voting twice can do at a third of them, and leaves a split for good. With nays a split ends, and one party voting twice on a close vote can have two versions written; the - longest chain heals it, and the votes show who. + votes show who, and the parties fork without it. * **A recount without a party that voted twice.** Its second vote can come at any time, at a history from before, and would undo a version long after it passed; and honest parties who backed one proposal, then another once the first was dead, would look as if they had voted twice. -* **The highest number for the current version.** A party that voted twice could - write the other version months later, and everything built since on the one it - replaced would go. +* **The longest chain from the first version.** It reads the same as the highest + number, but needs every version kept, and a tie decided where two chains part, long + behind both. +* **Of two federating changes at once, the lower hash.** A change made later to look as + old would win, and every node drop the federation with all that was built on it. +* **Freezing the policy once two versions share a number.** One party could stop the + federation at every close vote; the lower hash keeps nodes agreeing until the parties + fork. * **Forks within one document**, each side judging by its own chain of versions. It needs judging per chain, judging again when a node changes sides, node lists and remakes per chain. A swarm of its own needs none of it. @@ -517,11 +569,11 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang ## Changing the federation Every node of a swarm runs the same version of continuum today. A federated swarm's -parties can't be made to upgrade together, so what all its nodes must agree on is -named by the federation's number: the rules of this design, the envelope and how the -value of a place is read, what makes a change one Automerge writes, how a path and a -version are spelled and read, the longest chain, the rule for the time before, the -remake's check and its replay. The hash of a change and its encoding are Automerge's +parties can't be made to upgrade together, so what all its nodes must agree on is named +by the federation's number: the rules of this design, the envelope and how the value of +a place is read, what makes a change one Automerge writes, how a path and a version are +spelled and read, which version is current, the rule for the time before, the remake's +check, its replay and its order. The hash of a change and its encoding are Automerge's version's. A change to the federation is a design like this one, with the next number. A swarm @@ -535,7 +587,9 @@ The krebs registry today: users, their hosts, the hosts' names, addresses and ke On a federated swarm: * each krebs user is a party, its hosts in its namespace (`home/tv/hosts/laptop`: its - keys, its addresses as it uses them); + keys, its addresses as it uses them). Every decision takes two thirds of all + parties, quiet ones counted: the first version names the parties that will vote, + and lets the others in as they turn up; * its names under `names/r/tv/` and `names/w/tv/` by one rule each, its address blocks by a rule each; other names given by versions; * a tool reads what counts and writes what kartei's consumers read today. @@ -543,10 +597,12 @@ On a federated swarm: ## Stages 1. **The federated policy**: versions and what makes one valid, rules and paths, keys, - votes, passing and dead, the longest chain, judging by it; the meta's version - number and the order by it; tokens from one's own party's nodes only. A node that - doesn't know the policy stops taking changes. Until stage 4, a federated swarm takes - no remake. + votes, passing and dead, the current version, judging by it; the meta's version + number and the order by it; node lists, a node's party in its configuration, and + tokens from one's own party's nodes only; continuum's readings of a policy and of an + envelope taking the federated policy and the meta's version beside the six fields + it has today. A node that doesn't know the policy stops taking changes. Until stage + 4, a federated swarm takes no remake. 2. **What counts**, read by the current version and the keys; shown in the API. Housekeeping. Reports of a party that voted twice. 3. **Nodes**: membership by the node lists, a node syncing with members only, as a |
