aboutsummaryrefslogtreecommitdiffstats
Commit message (Collapse)AuthorAgeFilesLines
* store: a fold names itselftv29 hours3-0/+8
| | | | | | A swarm holding a store names its fold in its policy, `{"version": 2, "store": "<fold>"}`: the fold's name is a constant of the fold, `federation` for the federation and `test` for the fold made for the store's tests.
* docs: the federation's fold is builtfederation-2-stage-2tv30 hours3-19/+21
| | | | | 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.
* federation: fixed bytes of events, versions, roots and sizestv30 hours2-0/+127
| | | | | | | | | | | Vectors (`docs/federation-tests.md`, Fixed bytes) for a write and its signature and ID, the first version of two parties and its hash, the root it makes and its ID, a version event, an event whose value holds names that UTF-16 units sort otherwise than bytes, and events at federation 1's sizes and just past them: 256 KiB, 32 segments of 255 bytes, 64 nodes, integers to 2⁵³. Each value was computed apart from this code, by a script of its own: JCS by hand, Ed25519 by another library, and the signature's blob as OpenSSH's `PROTOCOL.sshsig` describes it, as `ssh-keygen -Y sign` makes it. Checking one against `ssh-keygen` itself is left to whoever has it at hand.
* federation: properties over generated federationstv30 hours2-0/+576
| | | | | | | | | | | | | | | | | | | | | Three to five parties write in their namespaces, change their key sets and node lists, propose versions and checkpoints on what they last caught up with, vote, and write the versions that pass; honest ones back one proposal on a version, an adversary votes as it likes and signs as another party with its own key, or where it may not write. Over such histories: * the store judges every event, and reads, as the model does, offered the same events in the same order, with an adversary and without; * what builds on a refused event is refused; * honest parties read the same whatever order the events come in, checkpoints and all; * after a checkpoint, what the store took the model takes, reading the whole history but for what the store refused as not above it, and the two read the same; the version naming the checkpoint is taken; * every version a store takes was backed by two thirds of the parties of the version it changes, in its history; * without a party voting twice, no two versions change one. A failing history is cut down and printed.
* federation: the model, a second reading of the federationtv30 hours2-0/+532
| | | | | | | | | | | The model (`docs/federation-tests.md`, The harness) reads the federation as `docs/federation.md` says, as plainly as it can: every event judged at its history read anew from the root, the version current there the highest-numbered written one, keys, key sets, node lists, votes, passing and dead, version events and the heads a version may name each worked out from that history alone; a node's own, the first of two versions changing one; and what counts read from everything taken. It keeps nothing but which events it took, and makes no checkpoint: slow and short, it is what the fold is checked against. A test takes it through a version passing, offered last event first.
* federation: the JCS test asks escapes JCS doesn't write, as escapestv31 hours1-2/+4
| | | | | | Two of the strings `json_written_otherwise_is_none` takes for none, an escaped U+2028 and an escaped `A`, stood in the file as the characters themselves, which JCS writes as they are: the test took them for none, and they read. They are built as escapes now.
* federation: a test for each attack marked unittv31 hours2-0/+1184
| | | | | | | | | | | | | | | | Each row of `docs/federation.md`'s attacks marked unit that the fold and the store in memory answer has its test, named by its row (`federation_attack_12`), with events made for it by the harness: keys that aren't their party's, bytes that are none, events of another federation or a fork, writes where a party held or holds no place, key sets and keys stolen or dropped, votes cast twice, at once, split, or at a history from before, versions that are none or written again late, two versions changing one in every order, forks and roots, checkpoints, events not above their heads, and heads a version may not name. `every_row_marked_unit_has_its_test` reads the table and this file, and checks that every row marked unit has its test, or waits for a later stage (what a node, a party's client or a tool does, and what a node tells of a fork), and that no test names a row that isn't there.
* federation: the federation as the store's foldtv31 hours3-1/+947
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | `Federation` is the store's fold for `docs/federation.md`. The state judging reads is the state of an event's history, which the store builds from the checkpoint and that history alone; so the version current there is the state's, the highest-numbered one written, and a history holding two versions of one number is refused. * A signed event's party is a party of the version current at its history. A write is signed by a key among its party's (those of its key set that counts, else those its version names) where a rule gives its party the place; a key set, node list, proposal or vote by a key its version names. * A vote is on the version current at its history, for a proposal proposed on it; a `true` only where every other proposal its party backs on that version is dead. Passing and dead go by the parties voting each way, a party with both counting for both. * A version event writes a proposal on the version current at its history, passed there, which is a version changing that one; one naming a checkpoint names heads after the current checkpoint at which it is current too, none in another's history, the version event above them. A node keeps a version event only where it changes the version it reads, or writes one it took. * What counts is read by the current version: of each party's writes at a place it may write, signed by a key among its party's, and of its key sets and node lists written under a version at least their `since`, the latest, then the lowest ID. A checkpoint keeps what counts at its heads and the proposals and votes on the version current there; a fork's root what counts at its heads by its version; the members are the nodes each party's node list names. Tests take a federation through writes, a key set, a proposal passing, one yes at a time, two versions changing one, a checkpoint and a node starting from it, and a fork. Events are read with their signature checked once, where they are judged.
* federation: events and checkpoints as bytes, and a harness that signs themtv31 hours3-0/+610
| | | | | | | | | | | | | | `Event::read` reads an event and says what makes one none (`docs/federation.md`, Events): bytes that aren't the JCS of the JSON they read as, larger than 256 KiB, with no dependency or more than 64, not ascending, or a field missing or more; and of a signed event, a party that is no party's name, a key or signature that doesn't read back to itself or doesn't hold, a path, key set, node list or vote spelled otherwise. A proposal is taken whatever it holds, named by its hash; a version event names a hash. `Checkpoint` reads and writes `{"at", "keeps", "version"}`, a root among them, which is no event. The tests' harness (`docs/federation-tests.md`, The harness) makes parties with keys from seeds, signs each kind of event as the design says, and spells versions out.
* federation: versions, their rules, and the paths they matchtv31 hours2-0/+539
| | | | | | | | | | | | | | | `Version::read` reads a version by itself, and says what makes one none (`docs/federation.md`, The policy): a field missing or more but for `checkpoint`, another federation, a number and `changes` that don't go together, keys and node lists not of the same parties, a party's name, its keys (one to 16, spelled as keys, none twice in the version) and its node list (up to 64 node IDs, none twice), checkpoint heads, and rules (a literal first segment and not `_continuum`, `{party}` once at most, `**` last only, a writer that is a party of it, `"{party}"` where the path holds `{party}`, or `false`; a path as a write's may be). `changes_validly` asks whether it changes another: one past its number, its hash, and each `since` its own number or the other's with the same keys, or node list. `writer` gives who writes at a path, by the first rule that matches; `only_moves_on` whether it changes nothing but its number, what it changes and its checkpoint.
* federation: keys, node IDs and signatures, each spelled one waytv31 hours2-0/+148
| | | | | | | | | | | A key is `ssh-ed25519`, one space, and its base64, padded and canonical, with no comment, its 32 bytes an Ed25519 public key; a node ID is spelled as continuum spells it, its key one too; and a signature is the SSHSIG blob of version 1 for the namespace `continuum-federation`, hashed with `sha512`, its reserved field empty, its key the event's, in base64, padded and canonical, unarmored, checked by continuum's strict check (`access::sshsig::verify_blob`) and read back to what `ssh-keygen` writes around it. `keys::sign` makes one, for clients and tests. Tests show each spelled otherwise taken for none.
* federation: JSON written one waytv31 hours2-0/+452
| | | | | | | | | | An event is the JCS encoding (RFC 8785) of a JSON object, within the limits federation 1 sets (`docs/federation.md`, Events). `jcs::read` gives the JSON bytes are only where they are what JCS writes of it: names sorted by their UTF-16 units and none twice, no whitespace, strings escaped as ECMAScript escapes them; and, beyond JCS, numbers only integers from −2⁵³ to 2⁵³, strings only whole Unicode characters, and objects and arrays nested up to 32 deep. Tests show what reads back and what is none, the order of names by UTF-16 units that byte order gets wrong, and the depth.
* store: a fork refuses what the store it came from builds on what its root keepstv32 hours1-1/+2
| | | | | | | The test of forks expected an event the store it came from took after the fork's heads to wait in the fork, but it builds on the put the fork's root keeps, which comes before the root, its one head: the fork refuses it, not above its root, as it refuses an event built on what a checkpoint keeps.
* federation-tests: vectors for JCS's order of names, and for the sizestv32 hours1-4/+7
| | | | | | | | JCS sorts an object's names by their UTF-16 units, not by their bytes or code points; the two differ for a name from U+E000 to U+FFFF beside one beyond U+FFFF. Names in events and versions are ASCII, but a value is any JSON: a vector with two such names catches a builder sorting strings as Rust does. And vectors at federation 1's sizes and just past them.
* store: a fork's later change ends once its events reach 1 MiBtv32 hours1-4/+5
| | | | | | | | | An event went into the change being filled unless it would take the events there past 1 MiB: whether a change was full hung on the next event. A node taking the root on its operator's word couldn't tell a change cut short, sent first, from the one every node builds, and by then held a change of that writer and number. Events now go into a change until their bytes there reach 1 MiB, and the next event begins the next change: each change is judged whole by itself.
* store: documents parted by a writer's two changes come together at the next ↵tv32 hours1-2/+4
| | | | | | | | remake The text said such documents "remake apart". By its own rules they come together at the next remake: one side decides, and the other rejoins its epoch; both decide, and of the two, the lower ID.
* store: grinding epoch IDs moves the nodes again for each lower onetv32 hours1-1/+1
| | | | | | | The row said nodes rejoin the lower epoch once a generation. Each lower ID found moves them again: of N tries, about ln N are lower than all before, so a billion hashes of a small snapshot make some twenty rejoins of the whole swarm, each node putting again what the new document lacks. Still slow, not wrong.
* store: a node follows no epoch with another policy, and reads nothing closed ↵tv32 hours1-8/+10
| | | | | | | | | in one An epoch's first change, which a rejoining node can't build, holds a snapshot: a made-up one may hold another policy, or what is closed in a swarm holding a store (users, bans, the topology). A node follows no epoch whose policy isn't its swarm's, and reads nothing closed in one it follows.
* store: the fold says how large an event may be, and the document judges by ittv32 hours4-3/+20
| | | | | | | | The document took any bytes that hash to their key, while the fold bounds events (the federation: 256 KiB): one change of any size filled every node until the next remake. How large an event may be is a question of the change alone, so the fold says it (`Fold::LARGEST`), the document refuses a change putting a larger one, and the store takes such bytes as none.
* store: where a pinned checkpoint comes from, and what a node keeps across a ↵tv32 hours1-8/+16
| | | | | | | | | | | | | | | | restart A pin is an ID, and the document holds a checkpoint only at `_continuum/checkpoint`, which only an epoch's first change writes: a swarm that moved once, and never remade, held its checkpoint nowhere, and a node told to join from a pinned one had nothing to start from. It finds it in its document: the document's checkpoint, or one the fold moves to at the history of an event the document holds, built at those heads from what the document holds, as the ID fixes its bytes whoever builds them. The document holds what that takes, as no remake leaves it out. And across a restart, a node reads its store from its document anew, from the document's checkpoint or the one its operator pinned, by its own refusals and drops, which it keeps in its file; it keeps nothing else of the store.
* store: a node follows no epoch whose snapshot holds an earlier checkpointtv32 hours1-8/+12
| | | | | | | | | Two listed nodes advertising a newer epoch make a ready node rejoin it, and a made-up epoch's snapshot may hold the root and nothing else. A node keeping its own checkpoint reads what is above it, but the new document then holds events whose history nobody puts again, and no node joining or restarting from it reaches the checkpoint the swarm holds. A node follows an epoch only where the snapshot's checkpoint is its document's, one it builds from that document, or one its operator pins; a row for the attack table.
* store: one rule for putting events againtv32 hours1-24/+29
| | | | | | | | | | | | | | | | | Events were put again by three rules: of a change continuum refused, every event of it and of what was built on it; after a switch, what a node held beyond the base that the new document lacked; after a rejoin, what it held. Between them an event could go: at a remake whose base came before a checkpoint, switched after nodes moved to it, the events between the base and its heads that the checkpoint didn't keep were in no node's store and left the document, and a store starting at the snapshot's checkpoint could reach the nodes' no more, pinned or not. One rule now: a node puts again every event its document lacks that a store starting at the document's checkpoint would take, but for its own refusals and drops, and that it has: one it holds, one in a change it refused, or one the document it left held. So no remake leaves out what a store starting at the new document's checkpoint takes, and the document holds what a node forgot until a remake whose snapshot holds that checkpoint or a later one.
* store: the snapshot is the store read from the document up to the basetv32 hours2-9/+11
| | | | | | | | | | 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 onetv32 hours1-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 refusedtv32 hours1-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 versiontv32 hours1-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 seedtv32 hours1-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 knowtv32 hours1-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 nametv32 hours2-11/+16
| | | | | | | | `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 waytv32 hours1-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 fieldtv32 hours1-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 nesttv32 hours1-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 onlytv32 hours1-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 nonetv32 hours1-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 headstv32 hours1-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 ↵tv32 hours1-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.
* federation: a node follows a party's `true`, not its proposaltv32 hours1-7/+9
| | | | | | | A node following a party backed a proposal that party proposed, but a proposal binds its proposer to nothing: its followers were bound by their yes, and the party it followed was free to back another. A node follows a `true` only, and one proposing a checkpoint backs it, so that the nodes following its party back it too.
* federation: a party that has a node vote by itself votes by hand through ittv32 hours1-3/+6
| | | | | | | | A party votes from one client, and may have one node vote by itself, but nothing put the two together: a node following a party's `false` on a proposal, and its operator backing the same proposal from a client, is a party voting twice, honestly. So such a party votes by hand only through that node, which keeps the party's one record of its votes and refuses a vote the record forbids.
* federation: voters back checkpoint heads that leave out nothing they held ↵tv32 hours2-7/+15
| | | | | | | | | | | | | | | | for a while A version that only moves the store on refuses what isn't above its heads, which its proposer chooses: heads built on little, just after the latest version event, would take back what was written since, a key set dropping a stolen key among it, and the stolen key would count again; a node following a `true` on checkpoints, or a voter checking only the version's fields, would back it unseen. So a party's client and a node voting by itself back a checkpoint only where everything they held for a while before it was proposed is among its heads, in their history, or above them, and a node shows what the heads lack, as for a fork. It is the voter's rule, by its own clock; nothing more is judged. A row for the attack table, and the property of votes a node casts by itself, say so.
* federation: groups that parted come together as parties come in, not by mergestv32 hours6-146/+84
| | | | | | | | | | | | | A merge, a fork at heads of several stores, named every party's keys anew, so that a party wrote its key set again before anything a key of its set signed counted there; and kept each side's values side by side, so that a value a party replaced on one side came back where the other side's write had the lower ID. Letting the other side's parties in, by a version or a fork naming them, who sign again what they keep as a party's client signs again what a move refused, does the same with nothing new. So a fork is at heads of one store: the fold makes its root from that store's state, and the store from its own heads (`Store::fork`). Merges' rows go, those after them move up, and Roads not taken says why, with merging in place.
* docs: the store and the federation say what of them is builttv32 hours3-17/+18
| | | | | store.md, federation.md and federation-tests.md said none of them was built; the store held in memory is, with a fold made for its tests and their properties.
* store: properties over generated historiestv32 hours3-0/+444
| | | | | | | | | | | | | | | | | | | | Two to four writers, each knowing what it wrote and what was written when it last caught up with the others, write the test fold's events on one or two events they know. Eras and cuts are numbered by their history, each number written once, or, for some properties, as often as it comes. A store offered them is checked against the whole history, read from the root with nothing forgotten: * it holds the same whatever order the events come in: every order putting each after what it builds on, for up to six events; some shuffled beyond; and backwards, where every event waits until the first comes; * it judges every event as the whole history does, the store's own refusals aside; * what builds on a refused event is refused; * what it took is above its checkpoint's heads, the cut naming the checkpoint among it, and it reads as its checkpoint and what it took, and as its whole history; * a node starting from its checkpoint holds what it holds. A failing history is cut down, events taken out with what builds on them for as long as it still fails, and printed.
* store: the test fold judges a cut by the checkpoint current at its historytv33 hours1-23/+83
| | | | | | | | | | | | | | | | A cut names heads above those the latest cut of its history names, and holding that cut, or, where its history holds none after the checkpoint the state starts from, heads after that checkpoint or its own; as federation.md has a version name heads after the checkpoint current at its history, at which that one is current too. It judged them by the checkpoint the store holds, which isn't the one current at the history of a cut taken in the same offer as the cut before it, before the store moves. A cut is above its heads as store.md says, each of its dependencies one of them or above them, so that moving to them refuses none of what named them. Of a checkpoint's heads, whose history a state starting from it doesn't hold, it takes none as built on another, nor on what the checkpoint keeps: starting from a checkpoint at two heads, one of them kept, it took the other as built on it, and refused the cut naming them.
* federation: a node starting from a checkpoint judges the version naming ittv33 hours1-1/+4
| | | | | | | A node starting from a checkpoint its operator pins holds neither the checkpoint before it nor the events between, so it can't check that the version naming its checkpoint names heads after the one current at that version, at which that one is current too. It takes that on its operator's word, and so takes the version, as every node did.
* federation: checkpoint heads at which the current checkpoint is current tootv33 hours1-7/+10
| | | | | | | | A version names checkpoint heads after the current checkpoint, and now heads at which that checkpoint is current too: the version naming it is among them or in their history. Without that, the version naming the current checkpoint could be after the next one's heads: every node that moved there holds it, and one starting from that checkpoint, which can't check heads before its own, couldn't judge it as they did.
* store: what is above some heads names nothing before themtv33 hours3-9/+17
| | | | | | | | | An event above some heads has each of its dependencies among them or above them, not only them all in its history. The store holds after its checkpoint only events whose dependencies are its heads and the events after them, and so it holds every event above them: one naming an event before them as well is refused by a node that moved, and never taken by one starting from the checkpoint, which never held what it names. Tests show it for an event offered after the move and one taken before it.
* store: forks and mergestv33 hours1-0/+87
| | | | | | | | The fold makes a fork's root from the states at heads of one store, or of several, which merges them, and what makes the fork; the store gives it the states, and the events the root keeps, from the stores holding them. A node holding those heads checks a root by building it. A fork and the stores it came from take nothing of each other: what each writes after builds on what the other doesn't hold.
* store: moving to a checkpoint, and starting from a pinned onetv33 hours2-8/+235
| | | | | | | | | | | | | Once the fold names heads of a later checkpoint (events after the store's, none in another's history), the store builds the checkpoint at them, keeps what the fold keeps, forgets what came before them, and refuses every event not above them, with what waits on such an event. What it forgot is held as accounted for: brought again, it is held, and an event built on it isn't above the heads. A store starts from a checkpoint its operator pins, its events building on the heads the checkpoint was built at. A node starting from a checkpoint must judge the event that named it as every node does; the fold for the tests counts the heads of the checkpoint a state starts from as after the checkpoint current at them, so that it does.
* store: a node's own refusals, and its operator's dropstv33 hours1-0/+126
| | | | | | | | | | Where its history takes an event but the fold has the node refuse it by what it took before (the federation's second version changing one), the store refuses it as its own. An operator may have the node drop events taken after its checkpoint, with everything built on them, and refuse them from then on; what the checkpoint keeps, or holds by ID, isn't dropped, as every event after it builds on that. The operator takes either back by allowing it, and what was refused for being built on it, to be offered again. The fold for the tests shows both with its eras.
* store: a store held in memory, and a fold for its teststv33 hours3-0/+803
| | | | | | | | | | | | | | | A store starts from its root, with the events the root keeps, and holds the events taken after it. An event offered is taken once the store holds its dependencies, where it is above the store's heads (built on an event after them, or on all of them) and the fold takes it at its history: the state its history reads as, folded from the checkpoint. An event waits for what it builds on, and is taken when that comes; one built on a refused event, or whose bytes are none of the fold's, is refused, with what waits for it. The fold made for the tests judges by history (a put refused where its key is locked), reads by what counts (a key's latest put, then the lowest ID), refuses by what a node took before (two eras of one number), and moves to checkpoints (cuts), as the federation does, so that the later stages' tests have something to exercise.