aboutsummaryrefslogtreecommitdiffstats
path: root/docs/federation.md
Commit message (Collapse)AuthorAgeFilesLines
* federation.md: a checkpoint after every version by default, forks followed ↵tv75 min.1-5/+7
| | | | | | | | | | | | by k of m Two places the text lagged behind: a node voting by itself proposes a checkpoint after every version that changes more than moving to one, unless its operator says otherwise, where the text had it after so many versions as its operator sets; and Roads not taken turned down a node following a party's word on which fork it went to, while the attack table now names following where k of m parties went as not yet built: it says that a single party's word is what was turned down.
* federation.md: what the attack table's answers lack yet, and what won't cometv93 min.1-8/+21
| | | | | | | | | | | | | | | | | | | | | | Reviewers read the design, not the plans kept apart from it. The attack table says now, where a row's answer isn't the best there could be, what would answer it better and isn't built (*Not yet*): * voting twice (12): nodes keeping the two votes, and forks announced in the swarm, followed where k of m named parties go; * parties that never vote (18): parties that write and don't vote; * a stolen key a version names (23): keys for some acts only, and acts taking two of a party's keys; * one first version, two federations (37): a salt in the first version; * joining from the root (63): a join asking its operator every time, not a restart; * a party named into another's zone (72): names of one label; * writing without bound (73): limits the parties set, perhaps per rule; * a followed party's key, stolen (78): following k of m; * more than 96 parties (79): votes gathered beneath the version event. Roads not taken says why a `true` isn't taken back, nor moved once its proposal is far short, and why no event says a party would back one.
* docs: purges in rounds, a version's size, a thief asking, one spellingtv93 min.1-1/+11
| | | | | | | | | | | | | | | | | What the docs left unsaid, each with a row of the attack table: * two thirds are of the current version's parties, so taking parties out in rounds leaves fewer to decide: of nine, four alone after two rounds; those taken out fork (row 75); * a version is one event, its parties and rules with it, within 256 KiB: a federation giving each name a rule of its own holds a few thousand names (federation.md, the rules guide); * a thief holding a key a version names can ask for the party's keys to be named anew as well as the party, and the others tell them apart by other means than the key (row 76, the keys guide); * rules match spellings, so `7` and `07` are two places, which two rules may give to two parties; the application takes one spelling of each (row 77, the rules guide).
* vote: a second `true` builds on the nays that freed its partytv93 min.1-4/+12
| | | | | | | | | | | | | | | | | | | | | | | The federation takes a party's `true` only where, at its history, every other proposal it backed on that version is dead. A party's client, and a node voting by itself, built a vote on the events proposing what it votes on alone. A proposal made while the party's first `true` was alive, at a history holding it, holds that `true` in its history, and not the nays that ended the first proposal later: the party's `true` on it was refused, though its record cast it. The compromise case: five back X, Y is proposed, X dies, its backers back Y. A vote now builds on one event proposing what it votes on, and on the nays that freed its party (`client::building`), so the first proposal is dead at its history too. One event proposing it is enough, so many proposing it again don't push a vote past the dependencies an event may name. A checkpoint's vote builds on its proposal alone: one of those nays in the history of its heads, named, would put the vote beside them. A party freed only after the heads were named backs that checkpoint not, and its client says so before casting; it backs one proposed after. Row 74 is tested (`federation_attack_74`); federation.md and the guides say so.
* docs: how large checkpoints grow, joining before the first, counting supporttv117 min.1-1/+21
| | | | | | | | | | | | | | | | | | | | What the docs left unsaid: * A checkpoint names every event that counts, 32 bytes each, and has no size limit, unlike an event; nothing bounds what a party writes where its rules let it, so every node, snapshot and fork's root holds as much as it writes. A party writing more than the others will hold is taken out by a version, or the others fork. Row 73 says so, and the rules guide. * Before the first checkpoint passed, a node joins from the root and nobody pins anything: a chain of old keys needs keys a version replaced, and a node voting by itself proposes a checkpoint after every version that changes more; until that passes, a joining node takes the first of two versions it judges, as row 63 has it. * A `true` binds; what binds nobody is said outside the votes. The voting guide shows how parties count their support first by plain writes, at a place a rule gives each (`intents/{party}/**`), read at `values` in GET /events/counts.
* continuum-party: which places a proposal gives another writertv2 hours1-1/+3
| | | | | | | | | | | | | | | Rules go by first match, and `{party}` matches only the names of the version's parties: admitting a party named as a segment of a place, or changing the rules or their order, moves who writes the places below it, and what their writer wrote there counts no more once the version passes. Nothing said so: a proposal showed only its fields' changes. `client::writers` names, of the places holding a value, those whose writer a version changes, as `place: before -> after` (`nobody` where no rule gives it one). `continuum-party proposals` prints them under each proposal's changes (`who writes …`), and a fork's check does for the fork's version (`writers` in POST /events/fork). The guides and federation.md say so; row 72 is tested (`federation_attack_72`).
* fork: a fork's check says what its version changes, rules among ittv2 hours1-2/+4
| | | | | | | | | | | | | | | A node holding the history up to a fork's heads said whether it builds the root, what it holds that those heads lack, and which parties' keys the fork's version gives otherwise. A founder could change the rules, or only their order, which says who writes where, and nobody joining was shown it. The check now says what the fork's version changes of the version current at those heads, a line each as a proposal's are shown (`client::changes`): `changes` in POST /events/fork, and `continuum-party check` prints them. federation.md and the forking guide say so, and that a fork's ID is compared whole: a founder trying versions can steer its first few digits.
* vote: a checkpoint after every version that changes more, unless told otherwisetv2 hours1-1/+1
| | | | | | | | | | | | | | | After a close vote, one key voting twice passes a rival version at a history from before the version that followed, the votes cast before counting with its own, any time until a checkpoint above that version: nodes that took the version refuse it, but one lagging behind, or joining from the root, may take it. A node voting by itself proposed a checkpoint after a version only where its operator set `--store-propose-versions`; now it does unless told otherwise (1 unless set; 0 never so). Versions that change more than moving to a checkpoint are rare, so the cost is a checkpoint each. A default set, store-propose-versions no longer asks for store-vote-key, as store-held-for and store-back-after don't.
* federation.md: a client builds on the heads it holds, a proposal or nottv2 hours1-4/+5
| | | | | | | | | | | | | federation.md said a client writing once a checkpoint is proposed builds only on what is above its heads. No client does: a party's client builds on the heads its node shows, and a node voting by itself on its own, whatever is proposed. Doing so would let any proposal, which costs one signature and binds nobody, steer where honest clients build: heads that never pass, or two proposals beside each other that can't both be obeyed. A proposer names the heads it holds as it proposes, so what is written after is above them unless built on an event beside them: written as it proposed, or on old history; the move refuses that, and its party's client signs it again.
* federation: which nodes know a revision, in counts and before a `true`tv3 hours1-2/+5
| | | | | | | | | | | | | | | | | | `GET /events/counts` says, of each node a party lists, what it said it speaks and knows (`knows`, by node ID): the wire versions, the oldest and the newest, and the newest revision of the federation it knows, by number and ID and as people read it, its number null where this continuum doesn't know it; null where it said nothing, a build from before SPEAKS or one the node didn't hear from; the node's own as it is. So the nodes still to upgrade before a revision passes show, every party's, where before a party's operators could check only their own. A party's client, backing a proposal that moves to another revision, warns of every node of any party not known to know it, a line a party naming each and what it said: once it passes, those stop at it till upgraded. `next` warns alike, of the revision it moves to, or of the later one it suggests. A warning, not a refusal: what a node heard is no proof, and a node not heard from may well be upgraded.
* federation: checked against the release a federation-<F>.<R> tag namesfederation-1.1tv4 hours1-4/+7
| | | | | | | | | | | | | | | | | | | A corpus of generated histories, committed, said what this code made of them, right or not, and held hundreds of kilobytes a revision; generated from code that changes, it could only be checked, never written again. Each release that makes a revision is tagged `federation-<F>.<R>`, the federation's number and the revision's (`federation-1.1`, revision 1 of federation 1). `scripts/federation-check` writes histories from this tree (`write_histories`, an ignored test): of each revision it knows and each kind the properties generate, those of a few seeds from a random one it says, and the attack tests' crafted ones, as each test offered them where nothing but offers made them. It judges them with `continuum-party judge` here and with the continuum the latest such tag names (or one given), built in a worktree and kept between runs, leaves out those whose root the tagged one reads as none, and says where the two differ. Run before a release, not by `cargo quick`. The corpus and its test are gone; the test plan and `federation.md` say how a release is checked.
* vote: a node proposes a checkpoint at the heads it holdstv12 hours1-34/+37
| | | | | | | | | | | | | | | | A node proposed a checkpoint at the heads of what it held for a while: every event written in that while, and every one built on an event beside those heads, as one party writing now and then on something old makes them, was beside them, and refused once the store moved. A voter whose while was shorter backed none, one whose while was longer backed it and lost those. It proposes at the heads its store holds, sorted: what was written before is in their history, and only what is written while the vote takes its course may be beside them. It proposes none where they are more than an event may name: under a revision with merge events, it merges them first; otherwise, what is written after does. `--store-held-for` keeps the voters' rule and how long a new proposal holds back a checkpoint. `federation.md`, the guides and the options say so.
* held: a node merges its store's heads beyond what an event may nametv12 hours1-1/+4
| | | | | | | | | | | | | | | Past 64 heads, no event is above them all, and what is written builds on the earliest 64 alone: where nobody writes, heads apart stay apart, and a checkpoint naming them is never written. Under a revision with merge events, a node its party lists signs merge events with its node key where its store holds more heads than an event may name, each on as many as it may, the earliest taken first, until no more are left (`Holding::merge`). The worker does so a random wait after the heads first were too many, as it puts again what the document lacks, so that of the members few do at once. `federation.md` says so under Nodes, and the guides say what a node writes by itself and what its log says.
* federation: merge events, the first revisiontv12 hours1-8/+26
| | | | | | | | | | | | | | | | | | What builds on many heads merges them, but only an event a party writes: in a quiet federation, heads beside each other stay so, and past 64 no event is above them all. Revision 1 (`merge-events`) adds merge events: `{"merge": true}`, signed with a node's own key, the `key` its Ed25519 key, for the party whose node list names it. One counts for nothing, and only gathers what it builds on into the history of what builds on it. Under the base revision, signed by a node its party doesn't list, or by a party's key, it is refused; the model alike. Generated federations begin at either revision, and their nodes merge. A node voting by itself backs no version changing the revision, on any version neither: its party's operators vote on that one, once their nodes run a continuum that knows it. `federation.md` lists the revisions, says what a merge event is, and row 71 is tested (`federation_attack_71`).
* federation: a version names the revision of federation 1 it followstv12 hours1-29/+48
| | | | | | | | | | | | | | | | | | What every node must agree on was named by the federation's number alone, and a change that only took more kept it: a party could use it before every node ran it, and nodes not upgraded refused what followed and parted from the others. A version now names the revision it follows by its ID (`"revision": "<ID>"`), the SHA-256 of the JCS list of the features it adds to the base revision federation 1 began with (`federation::revision`); a version naming none follows the base revision, ECDSA keys among it, so the versions written so far read as they did. A version names the base revision only by leaving `revision` out, and a revision no earlier than the one of the version it changes. A continuum that doesn't know a revision, another build's among them, can't read a version naming it: it stops at a version event writing one, and says which revision and what it knows. There are no revisions yet but the base revision. `federation.md` says how a revision is rolled out, then passed, and what a later continuum may leave out; the upgrades guide, and the one on a node stopped, alike.
* docs: quiet parties, proof of voting twice, the next change keeping the numbertv14 hours1-6/+20
| | | | | | | | | | | | | | 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.
* vote: propose a checkpoint after so many versionstv14 hours1-5/+11
| | | | | | | | | | | | | | The votes cast before count at a history from before too: a proposal that died, or a rival, needs there only the votes it lacked, and after a close vote one key voting twice is enough, at any time until a checkpoint above the version that followed. Nodes that took that version refuse it; one lagging behind, or joining from the root, may take it. `federation.md` said it took the keys of two thirds of the parties. A node voting by itself proposes a checkpoint once so many versions were written since its store's (`--store-propose-versions`), as the design lists: with 1, after every version, so that what keys voting twice grow beside a version ends at a checkpoint above it. `federation.md` says how little a rival version takes, row 20 too, and the guides the option.
* vote: a proposal holds back checkpoints by a third, or new for a whiletv14 hours1-12/+15
| | | | | | | | | | | | | | | A node voting by itself proposes no checkpoint beside a proposal that holds it back, as the checkpoint would lapse it, and a follower backs none so. A proposal held one back where someone but its proposer backed it: two parties, or one and a stolen key, kept a junk proposal alive, and no automatic checkpoint came while it lived, ending it taking nays from more than a third each round. And one new, its proposer alone backing it, was lapsed at once by a checkpoint its writes brought about. A proposal that can still pass holds back now where a third of the parties back it, someone but its proposer among them; or where it is new, held for less than a while (`--store-held-for`), and its proposer has none older on the version: so it is heard before a checkpoint lapses it, once a version for each proposer. Row 67 says so, and a test of nine parties checks it.
* vote: a follower copies no false, lapses nothing others back, waits after a movetv14 hours1-10/+17
| | | | | | | | | | | | | | | | | | | A node following a party (`--store-follow`) handed it more than the text said: * it copied the party's `false`: one party's nay freed bound followers, and its `true` shown to some and its `false` to the rest passed a checkpoint at one history and made it dead at another. It copies the `true` alone now, on any version too; * a checkpoint lapses every other proposal: the followed party ended any proposal it disliked by passing one. A node follows a checkpoint only where no proposal that changes more can still pass that someone but its proposer backs; * nothing bounded how often the store moved, so fresh events could be left out of every checkpoint; and a node just started held nothing for a while, so the voters' rule kept nothing. A node backs, and proposes, a checkpoint only once its store held its checkpoint, or ran, for a while (`--store-back-after`, ten minutes unless set), by itself or by hand. `federation.md` says what following hands over, and row 58 what a follower on any version copies; the guides and the example say the rest.
* federation: a checkpoint of 64 heads at most, a version of 96 partiestv14 hours1-35/+37
| | | | | | | | | | | No event is above more heads than it may name dependencies (64): a version naming more for its checkpoint is never written. A node voting by itself proposed one at whatever heads it held for a while, however many; it now proposes none past 64, as what is written merges them, and a party's client backs none such (`client::backable`). A version event names the votes passing a proposal, two thirds of its version's parties: past 96 parties, more than an event may name. A version names at most 96 now (`version::PARTIES`).
* federation: votes on the events proposing a checkpoint above its headstv14 hours1-24/+27
| | | | | | | | | | | | | | | Anyone could propose a checkpoint's version again, by an event beside its heads. A node voting by itself, and a party's client, built a vote on every event proposing what it voted on, so every vote was beside the heads, and no version event written on them was taken: the checkpoint could never move the store. And the voters' rule refused it once that event was held for a while, as the heads left it out. They vote on the events proposing it that are above the heads it names (`State::proposing`), which `GET /events/counts` lists as `proposals`; where there are none, `none` says so, the node casts nothing and the client says why. The voters' rule leaves proposals and votes aside, as they lapse with the move. Row 70 is tested (`federation_attack_70`).
* fold: of a party's lists, those written under the latest version firsttv14 hours1-2/+7
| | | | | | | | | | | | | | | | | | A key a version names, stolen, could write its party's node list at a history from before the version that named the party's keys anew: written under the version before, it counted, as naming keys anew leaves a list's `since` alone, and beside the list the party wrote under the new version the lower ID won. The thief signed a few, kept the lowest, and did so again after every list the party wrote. Of a party's key sets, and of its node lists, those written under the latest version now come first, then what no other has in its history, then the lowest ID; the model alike. A list the party writes under the version that replaced the key stays, as `federation.md` says. Key sets were safe already, by their `since`; one rule serves both. This changes what counts where two of a party's lists, written under different versions, are beside each other: nodes read them alike only once all run it. Row 69 is tested (`federation_attack_69`).
* store: a stopped node leaves out none of what it holds backtv20 hours1-3/+4
| | | | | | | | | | | | | | | A store that stopped can't tell which of what it holds back will be taken, nor which of what waits: `Store::held_back` gives both, each after what it builds on. A node leaves out none of it: it puts it again where its document lacks it (`Holding::lacking`), a remake's snapshot holds it (`Holding::at_base`), and after a switch or a rejoin it puts again what of it the document it left held (`Holding::left`). A remake while nodes are stopped no longer drops what was put since the stop, nor the event they stopped at. Tested: a node keeps what it holds back, what waited among it, through a snapshot, and a store read anew from that stops there again; and a simulation: a swarm stopped at a version compacts, a node away meanwhile rejoins and one started again with nothing reads the new epoch, each stopping there, holding back what came after, until their operators have them drop that event.
* federation: a joining node takes the first of two versions, as any nodetv21 hours1-9/+8
| | | | | | | | | | | | Of two versions changing the one it reads, a node takes the first it judges, joining or not, and reports the other: its operator chooses, by dropping and allowing. No rule holds a joining node back until it has synced with every seed: it learns of the other members as it syncs, and its seeds may go away. federation.md drops the joining rule from Changing the policy, and says so in what isn't promised and in row 63; the guides say what a joining node takes. Row 63 is tested (`federation_attack_63`): from the root, either side first, the operator switching sides; and pinned at a later checkpoint, the chain old keys grew never taken.
* federation: a node stops at a version it doesn't readtv21 hours1-15/+29
| | | | | | | | | | | | | | | | | | | | | | A version event writing a proposal passed on the version a node reads, which doesn't read as a version there (of a later federation, using what a later continuum takes, or none at all), the node can't judge: `Fold::stops`. The store stops at it: it takes nothing and refuses nothing from then on, holding back whatever comes, that event first (`Offered::Stopped`), and keeps none of it across a restart, where it stops there again. One beside the version the node reads is refused of its own, as any other. Its operator has it drop that event (`POST /admin/events/drop`), or one it builds on: it is refused as dropped, or as built on what was, any version event writing that version with it, kept in the store file; the node judges what it held back and goes on under the version before. Allowed again, it stops there once more. The node logs the stop and its end; `GET /events` names the event, why, and how many it holds back (`stopped`); a put answers `stopped`, written into the document all the same; a node voting by itself casts nothing while stopped. The test fold's eras tagged `new` stop a store. Row 39 is tested (`federation_attack_39`); of rows 9, 10 and 48, a node stops at the version event.
* docs: references to another document's section linked to ittv27 hours1-64/+67
| | | | | | | | Where a document names a section of another after linking to it ("([`store.md`](store.md), Pinned checkpoints)"), the name links to that section too, by the id both GitHub and cgit's about filter give its heading; paragraphs that grew past the width are wrapped anew, links and code kept on one line each.
* docs: references to a section of the same document linked to ittv28 hours1-128/+138
| | | | | | | | Where a document names one of its own sections in parentheses ("(What counts, 5)", "(Joining, below)"), the name links to the section by its GitHub-style ID; paragraphs that grew past the width are wrapped anew, links and code kept on one line each. References to another document's sections stay as they are.
* attacks: row 62 with an ECDSA signature spelled otherwisetv29 hours1-1/+1
| | | | | | | Row 62 names an ECDSA signature's twins, `s` high (the order less `s`) and `r` or `s` with zeros more in front, each none. Its test offers the ECDSA vector's write with each (`keys::respelled`) to a store whose root names that key, and has it take the write as it was signed.
* federation.md, guides: a change taking what was refused keeps the numbertv29 hours1-0/+7
| | | | | | | | A change that only has the federation take what it refused, reading nothing it took otherwise, as ecdsa-sha2-nistp256 keys, keeps the federation's number: it is rolled out to every node first, and used after. A node that doesn't take it refuses what uses it, a version naming such a key among them.
* federation.md, federation-tests.md: ecdsa-sha2-nistp256 keys, their ↵slopulus44 hours1-15/+23
| | | | | | | | signature low-S A key is `ssh-ed25519` or `ecdsa-sha2-nistp256`, spelled alike; an ECDSA signature is over SHA-256, its `s` low and `r` and `s` SSH's shortest mpints, so that it is spelled one way. The vectors and the agent test, among the harness's.
* federation.md, federation-tests.md: the stages end with remakesdesigns/federation-1-stage-5tv2 days1-3/+1
| | | | | | What a federation is used for is read and written through a node's API: kartei's entries are signed in by their parties and read from what counts there, with no stage of their own.
* federation.md: kartei's files, identifiers and rules on a federated swarmtv2 days1-11/+25
| | | | | | | | | The registry holds each kartei namespace in its party's, a place per file. What kartei's consumers read as one for all (host and user names, the names hosts go by, addresses and blocks in every net but `internet`) is shared, at places of its own, given by krebs's rules: a party's by its name, and what kartei gives it beyond them by a rule each in the first version. What kartei's consumers read is written out from what counts, but for what names an identifier the current version doesn't give its party.
* federation: votes build on the events proposing what they vote ontv3 days1-14/+16
| | | | | | | | | | A node voting by itself, and a party's client, signed a vote on the heads the node held: where those held what is beside a checkpoint's heads (a party's writes made while the swarm was parted, say), the vote wasn't above them, and a version event written on it was refused, so the checkpoint never moved, though it passed. Both now vote on the events proposing what they vote on, and a node proposes a checkpoint on the heads it names: so their votes are above those heads wherever the proposal is.
* docs: votes a node casts by itself are builttv3 days1-4/+6
| | | | | | The federation's design says that votes a node casts by itself are built: following parties and proposing checkpoints, backing a checkpoint by the voters' rule, and its party voting by hand through it.
* docs: what of the federation is builttv3 days1-7/+11
| | | | | | | The federation's design says what of it is built: the store in a swarm's document, members by the federation and the store at a node's API, as the store's design says; and a party's client, which signs its party's events, votes by its record, signs again what a move refused, and names a party that voted twice.
* docs: the federation's fold is builtdesigns/federation-1-stage-2tv3 days1-5/+6
| | | | | store.md, federation.md and federation-tests.md say what of them is built: beside the store held in memory, the federation as its fold, with its byte formats, and their tests.
* store: the snapshot is the store read from the document up to the basetv3 days1-2/+2
| | | | | | | | | | The snapshot held the store "as the node reads it at the base". A node that moved to a later checkpoint since the base forgot what came before it, and reads the store at the base no more; one that didn't move yet still does: the two built different snapshots from one base, and the checkpoint the swarm held could leave the document with no node able to give it back. The snapshot is the store a node reads from the document up to the base, starting at the document's checkpoint, by its own refusals and drops: every node holding the base builds the same, whenever it moved.
* federation: a client writes its record of votes before it sends onetv3 days1-6/+8
| | | | | | | A party's client votes by what it keeps, never by what a node shows, but nothing said what one that lost its record does. It can't go by a node: a `true` it sent through one may be held back there. So it writes its record before it sends a vote, and one that lost its record casts nothing on the current version.
* federation: an event whose history holds two versions changing one is refusedtv3 days1-1/+2
| | | | | | No node takes such a history, as each refuses one of the two, but judging, and a model reading every history anew, are given it, and must say the same of it: it is refused, as no version is current there.
* federation: what a checkpoint keeps is read as written under its versiontv3 days1-2/+5
| | | | | | | | An event doesn't name the version it was written under, and a node starting from a checkpoint holds none of the kept events' histories. It works out, but `start` has to assume it, and the text didn't say: a node reads what a checkpoint keeps as written under its version, as each was written under that one or an earlier and counts there, a kept proposal is on it, and a later `since` that leaves one out is past it.
* federation: a node is still joining until it synced with every seedtv3 days1-5/+7
| | | | | | | | | Of two versions changing one, a node still joining takes neither. Continuum's lifecycle has a node `Joining` only until its first sync, with one peer, its catch-up source: one node of the adversary's answering first showed it one chain alone, which it took, and refused the other from everyone else. For this, a node is still joining, from its start or a rejoin, until it has synced with every seed its operator named; and what isn't promised is a node joining whose seeds are all the adversary's.
* federation: whether a checkpoint passed is the operator's to knowtv3 days1-5/+6
| | | | | | Once a checkpoint passed, a node joins from a pinned one; but a node started from the root can't tell that one passed, as a chain old keys grew need name none. It is its operator's to know, not the node's to refuse.
* federation: every event's shape, and the fold's nametv3 days1-10/+15
| | | | | | | | `keys`, `nodes` and `proposal` events had no shape written, a vote's was written as if it were the event, and the fold had no name, though the genesis change is built byte for byte from the policy naming it. Each field an event may have is written with what it holds, a version's hash as an ID is, and the fold is named `federation`: `{"version": 2, "store": "federation"}`.
* federation: keys in versions and key sets, and node IDs, are spelled one waytv3 days1-31/+34
| | | | | | | | | | An event's `key` was spelled out; the keys a version and a key set name, and node IDs, weren't, and whether a version is one hung on it: a key's base64 not canonical, a comment, 32 bytes that are no Ed25519 key, a key twice in a set, a node ID in capitals or twice. Keys are spelled as `key` is, with no comment, their 32 bytes an Ed25519 public key; node IDs as continuum spells them, `continuum:` and 64 lower-case hex digits; and none of either twice in a list. The example version loses its keys' comments.
* federation: a signature's blob holds an empty reserved fieldtv3 days1-3/+4
| | | | | | | | The design named the blob's hash and key, and said a signature is checked as continuum checks a user's, which takes `sha256` beside `sha512`, and any reserved field. Only the signer can vary that field, as it is signed, but one builder asked it empty and another didn't. It is empty, as `ssh-keygen` writes it, and the hash `sha512`, beyond what continuum's check asks.
* federation: how deep an event may nesttv3 days1-0/+1
| | | | | | 256 KiB hold arrays some hundred thousand deep. A JSON reader stops at a depth of its own, or none, or falls over: two builders' nodes parted on such an event. An event nests objects and arrays up to 32 deep, its own object the first.
* federation: numbers are integers anywhere in an event, not in values onlytv3 days1-2/+2
| | | | | | | | Integers were asked of values alone. A proposal holding `1.5` or `1e21` is good JCS, so to judge it a builder needed all of ECMAScript's number printing, for this alone, and one reading integers only took it for no event. Numbers anywhere in an event are integers from −2⁵³ to 2⁵³, and strings anywhere are whole Unicode characters: floats, and the hardest part of JCS with them, go.
* federation: what makes an event none, and what makes a version nonetv3 days1-12/+12
| | | | | | | | | | | The sizes federation 1 allows listed a party's keys "in its version or its set" among what makes an event none, while a proposal is taken whatever version it holds: a proposal giving a party 17 keys was no event to one builder, and a proposal that is no version to another, who parted at the first event with it in its history. The list now says what of an event makes it none (its size and dependencies, a key set's keys, a node list's nodes, a write's path, its values), and a version is none where it gives a party more keys than a key set may hold, more nodes than a node list, or a rule a longer path than a write's.
* federation: a vote on a checkpoint isn't judged against its headstv3 days1-5/+6
| | | | | | | | | | A vote on a version naming a checkpoint was taken only where it was above the heads. It follows from the version event's being above them: the version event is taken only there, and with it every vote it is written on, as everything in the history of an event above some heads that isn't in theirs is above them. Two rules are left: the proposal is a version only where it is above the heads, and a version event writing it is taken only where it is above them. A vote cast beside them binds its party as any yes does, until the move refuses it; an honest client builds only on what is above them.
* federation: a node follows on checkpoints only, by default, a `false` as a ↵tv3 days1-10/+10
| | | | | | | | | | | | | | | `true` By default a node followed a party's `false` on any proposal. Where that party and its followers are more than a third of the parties, one key, the one kept on a node, ended every proposal, the one naming that key anew among them. By default a node now follows only on a version that only moves to a checkpoint, both ways, and following on any version, `false` among it, is its operator's choice. The follower's `false` was also how a proposal nobody else backs stopped holding back automatic checkpoints. Instead, a node proposing a checkpoint goes ahead beside a proposal it wouldn't back that nobody backs but its proposer; it still waits for any it would back, or that others back.