| Commit message (Collapse) | Author | Age | Files | Lines |
| ... | |
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A federation starts with a swarm of its own, its genesis change writing
the federated policy and the first version: nothing is from before it,
so the time before, the federating change and values from before go,
and nothing writes the policy's place after the genesis change. A
running swarm doesn't become federated; that is left as a road not
taken.
A remake replays a party's votes before its key sets where neither saw
the other, so a vote counts as cast across a remake too; a party that
wrote two key sets at once is answered as one voting twice. A version
is replayed in one change with the keys it sets, and a replay holds for
any base. A `null` the epoch's first change holds goes only at a remake,
and housekeeping deletes one only where this epoch's history holds what
it covers. A node is a member while the party its own entry names lists
it; another party's list does nothing. A proposal counts as written,
like a vote. A fork is named by its first version and the heads it
names, in its genesis change; `went/` says where to those who follow.
Leftovers: the unsigned key envelope's meta; "can bring back" reaching
deletions; the first link checked against the place as the deletion
leaves it; "is left out"; the attack rows, renumbered.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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 this is the end of the chain, read without the
versions behind it, which housekeeping may delete.
A double vote both sides built on can be read one way and then the
other while votes cast before the sides met come in, and what was
written under the version not read ranks with the other's, a thief's
key set among them. The parties answer it by forking without the party
that voted twice; a report of one comes from the history, never from
the document as a whole.
A node's party is its operator's, in its configuration: another party
listing it changes nothing. Replay goes by history and by the version
named, deletes what counts no more beneath a new holder's chain, and may
leave out a `null` once a later version is current; housekeeping may
delete a `null` once all it covers was signed by keys its party dropped.
The federating change is the one the policy's writes lead back to, and
one beside it is refused: a tie broken by hash would let a change made
later to look as old take its place. A fork's first version names the
highest at the fork's heads, the fork is named by its genesis change's
hash, and joiners are told whose keys the fork changed.
Leftovers: the keys a version sets spelled as an unsigned envelope;
client advice out of the rules; `null` at a proposal's place gone;
literal rules before `{party}` ones; node lists in stage 1; rows for
what this opens.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Every envelope's meta names the version current where it was written, and a
place's value goes by version number, then seq, then digest: what is signed
under a later version is ahead of any chain written at a history from before
it, by a former holder or a dropped key. Only a version revokes a key; the
change writing a version writes the keys it sets.
The current version is the end of the longest chain of written versions, a
tie decided by the lower hash where they part: a version written late beside
one the parties went on from changes nothing. A party that voted twice shows
by its two signed votes, which nodes report and clients keep; taking it out
is a version.
Votes count by the keys at their own history and go only with their version.
Becoming federated is closed by the rule continuum keeps for a swarm turned
strict; leaving is a fork. A fork's genesis holds only the group's version,
numbered past the highest, and is the new swarm's name. Any envelope deleted
can be put back; the first-envelope rule goes. Replay is continuum's chain
replay, with versions in the order written. The attack table gains the rows
these open.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What a place holds is read by its envelopes' `seq`, the current
version by its number, a party's keys by one envelope's `seq`: nothing
by the order of operations, which a change's writer steers.
- A version is a string named by its hash, numbered, written at
`versions/<hash>` by any member once it passed, counting by its
votes and not its writer, and current only once written.
- A vote is `true` or `false` at `votes/<party>/<version>/<proposal>`
and never changes. A proposal passes with the share's yeses and is
dead once the nays leave too few; a party backs one proposal at a
time, and another once the first is dead. So a split ends on its
version. Two versions with one number are written only if a party
voted twice; the lower hash is read.
- A party's keys are one envelope, or what a version set. A first
envelope at a place names its party's keys, so it can't be put back
once they changed; deletions need no rule of their own.
- Rules start with a literal segment; `{party}` is a whole segment;
a writer is a party, `{party}` or `false`. How names and addresses
are spelled as paths is the application's.
- What counts no more: five things; any member deletes them, judged
by the document the deleting change makes.
- A fork is a swarm of its own, started from the document with the
version the group wants.
- Becoming federated closes the history before it. A node that didn't
hold the epoch before takes a remake on its peers' word, which
promise 1 now says. Tokens come from one's own party's nodes only.
- A list of attacks, each with what happens and how it is tested.
|
| |
|
|
|
| |
"Would" read as a promise someone might rely on; whether a key added
again brings anything back is nothing the design says.
|
| |
|
|
|
|
| |
Nothing remembers removed keys, so no node can refuse one added again;
the design says it is the party's to keep from doing, as it would
bring back what that key signed.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- What counts no more is listed, five things and nothing else: a value
where its party may not write; one whose key went; a deletion once
its party holds none of the keys it names; a proposal on a version
that isn't current, and its votes; the value not shown of two
written at once.
- Any member deletes those, but what stopped counting because its key
went only its party, until it holds no keys at all; housekeeping
thereby empties a place only where nothing could be put back, so an
envelope that replaced nothing never comes back. A deletion names the
keys its party held, and stays while it holds any of them; a removed
key is never added again.
- A fork is following the chain that begins with a proposal; nothing
is written for it. `went` stays apart, and so does voting, which
moves nobody.
- A version may name another federation, or none with the policy the
swarm goes on with.
- Several people may keep one party, and one person be in several.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
member
- A swarm becomes federated by writing the federated policy with its
first version, at genesis or later; what was written before counts
only where a party signed it as the first version allows.
- A rule's writer is `true` or `false` for every party or none, and
`share` two whole numbers ([2, 3]), so nothing needs parsing or
rounding.
- At most `limits.proposals` of one party's proposals on one version
are held at a time; it deletes one to make room.
- The keys a version sets are written as the party's keys by the
change that makes the version current; the version holds them for
nothing else.
- What doesn't count may be deleted by any member, judged by what
counted at the deleting change's history; the writer that made it
stale deletes it, others only what they find stale. An envelope
signed with a key still held can be put back where nothing is.
- Every proposal is a chance to fork: a group follows one by writing
it as the current version of a chain named by its hash. No forks
path.
- What a party's nodes do of themselves (following others, voting by
bounds) is their operators' business and written nowhere.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The design asks less of continuum and of remakes:
- Parties vote; there are no voters apart from them.
- The policy's rules say who writes where: paths with `*`, `**` and
`{party}` (`names/{party}.r`), each naming its writer, the first
that matches deciding; shared identifiers are rules, given by
versions. The federation's own paths are fixed by its number.
- A swarm says which federation it follows (this design is 1); a
change to the federation is a design of its own with the next number.
- A passed proposal is written as the chain's current version by any
party; what lapsed, or doesn't count, any party may delete.
- A value counts only while the key that signed it is its party's: a
removed key takes back all it signed, the party signs again what was
its own. Deletions stay until the key of what they deleted goes.
- Agreement holds while fewer than a third of the parties vote twice,
as the design now says.
- A party without nodes writes through any node; node lists say who
is a member and whom a node syncs with.
- Remakes are continuum's, when and with whom it likes, of any kind
that loses and adds nothing; writes after the base are each judged
again, with no replay window.
- A fork is a chain of its own within the same document; nodes follow
one chain and sync with its parties' nodes only.
- What Automerge limits are recommendations; denial of service breaks
no promise.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The design is rewritten from the start, around what it is for: handing
out identifiers and giving every party a namespace everyone reads.
A party is a voter. The policy is a chain of versions: the voters and
their keys, the kinds of shared identifiers and who holds each, and
the numbers. A proposal changes one version, and becomes current once
two thirds of that version's voters voted for it; a vote is never
replaced, and one voter's two votes at once count for neither, so at
most one proposal changes a version and every node that holds the
same votes reads the same policy. Identifiers are given, taken back
and given again by versions, never first come; nothing waits on time.
A change is judged at its history by the version current there; what
counts is read by the version current in the document. A stolen key
is replaced by its party, or by a version. Remakes start the document
anew for Automerge's sake only: acks by voter, a majority of them; the
snapshot holds what counts; every envelope after the base is judged
again, within a replay window counted in epochs. Any group forks with
the version it wants, and nodes follow by their own rule, which may
name parties to follow and vote with.
Gone: roots, vouching and lines, claims and witnesses, lengths of
time, cuts, floors, branches, switch records, and the catalogue of
attacks.
|
| |
|
|
|
|
|
| |
The words this round adds to those the glossary gets with the
federated case: a branch, which an envelope names; a floor, which keeps
out what a remake left out; and a party, now for writers as for a
budget.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* One node commits a remake alone, as the trust table and the code
have it; what is not promised, Remakes and the row of most nodes
said the alive peers did.
* What a third of the voters do at once, stamping as they like, now
names a decision final and what stopped counting for good.
* The voters are no longer an epoch's: what is not promised, promise
7's argument and a row said so.
* Why it holds says how a remake changes nothing as it now does.
* A remake's proposal and decision, continuum's records, are said to
be no proposal or decision of the voters.
* The snapshot names, for each user it holds without keys, the root
that gives them, and the genesis change's fields are said.
* A node builds one snapshot a coordinator and epoch at most.
* What to watch has the signals of remakes this round needs.
* The attack table ends before the next heading.
|
| |
|
|
|
|
|
|
|
|
|
| |
Two sides of a partition both decide where more than a third of the
voters have nodes and votes on each. Past `final` each decision is
final on its side, and when the sides meet, "no decision of its matter
holds instead whose proposal wasn't signed in sight of it" blocked
both ways. Two final decisions of one matter now give way to each
other as decisions not final do: the higher number, then the lower
digest; for who votes, first the one the roots' nodes saw decided
first.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
A value brought along counted while its user had signed none at its
place in the new epoch. So a node that held back a value its user had
handed it, and that the user had since written past, wrote it after a
remake whose snapshot held the newer one, and it showed until the
user wrote there again. It now gives way to the snapshot's value at
its place unless its `prev` names that one.
And what a proposal brought along was signed in sight of, which a
final decision and the voters before ask, couldn't be looked at: such
a proposal is now in sight of all the snapshot holds and of nothing
brought along.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Anything past its limit stopped counting for good once seen so for
`final`, so a limit lowered for that long left out for good every key,
node, creation, vouch and claim past it, raised again or not. And
where `gone` is longer than `final`, a user that gave itself up lost,
at `final`, what the text says a cut takes back until it is gone.
What was past its limit already where it was signed still stops
counting for good; what only a limit lowered since puts past it
waits, as long as the limit is lower. A user that gave itself up is
out by its own word, and what it had waits with it until it is gone.
And the numbers say what a `final` of nothing does: no cut brings back
anything given up.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
One user reached `remakeWriters` in two hours with its sixteen
creations' writers, or `remakeChanges` within a day at its budget, and
did it again in every epoch: a remake every two hours, an archive each,
a snapshot each on every node.
Writers now count per party, as the budget does, so creating users
starts no more of them; no remake comes before the epoch has been
seen for `remakeAfter` (recommended 7 days); and the budget recommended
is 60 changes, 1 MiB and 10 000 operations a party an hour, plenty for
a registry.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A party for a budget was a user with the users below it that no line
reaches but through it. Every line starts at a root, so a root's party
held every user only it had brought in: one newcomer writing at the
budget's pace stalled the root's witness changes at every node.
A user's party is now headed by the highest user below the roots
through whom all its lines pass: a user a root created heads its own,
and a root is its own party. A root's node's witness changes, one a
`witness` at most, draw on no party.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The voters before couldn't be read for who votes itself: of two
decisions on who votes by one list, either could be taken as the one
that replaced it. Of the same number, the lower digest held, and a
list made up by the voters a decision replaced, voters no more and of
whom nothing is assumed, could hold and become final.
Of decisions on who votes made by one list, the first decided now
holds: one is late against another where a root's node committed a
change with the other decided and it not, and a later one is a
decision of voters already replaced; where the roots' nodes show both
orders or neither, the higher number, then the lower digest.
And a node takes a proposal up only where it says its signer saw all
the node held a window before it takes it up, not before it received
it: a list proposed in January can't be decided in June, so the voters
before lose a window's decisions at most.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Whether a user is a root is read where each thing it did was done. A
root the voters left out signed creations, each saying it saw only
changes from before the decision, and they were a root's there: the
seats', without a limit, taken back only by every root together. And
one change of its node, on heads from before the decision, witnessed
as a root's and contested every name not yet final.
What a root a decision leaves out signed, and what its nodes
committed, is now a root's only where that decision's proposal was
signed in sight of it, or where another root's node had it in its
history without the decision, as for the voters before. What it
settled and created before keeps its standing; what it backdates is
an ordinary user's.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A member acks one remake an epoch until it is aborted, and in a
federated swarm only a coordinator wrote of a remake beside the acks.
So a node that proposed the moment a remake was due and never decided,
or an honest coordinator that died, ended the epoch's remakes, and
with them the bound on its heap.
Any node now aborts a remake that expired, once a grace has passed by
its own clock, as an operator does in every swarm; the abort frees the
acks. A remake committed is followed whatever abort came beside it.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Of two remakes of one epoch every node went to the lower ID, and
nothing bounded how late the second came. So one node, keeping the
epoch as an archive, committed a second remake a month into the next
epoch, its ID ground lower, and every node moved to it; a node walking
the archives went the same way, into whatever branch that node
continued.
The one whose new epoch holds switch records of nodes of more than a
third of the voters, a node counted for one voter, now comes first;
the lower ID decides only between two that both do, or both don't. A
remake committed late, beside one the swarm went to, moves nobody,
and a walker reads the same from the two new epochs. The paragraph
under Partitions that repeated the rule goes.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A length that began after a remake's base had nothing in the snapshot,
so it started anew in the next epoch: a claim final after the base
was contestable again, a user gone after it waited again. A decision
decided after the base waited for the nodes of two thirds of the
voters to take it up again, who may be gone by then. And a node's
change written between its switch record and the envelopes it named
witnessed against them.
A switch record now also names each length that began for its node
after the base, from the stamp it began at; the claims it held
standing with no rival there; and the proposals it took up after the
base, which are its records in the new epoch, judged against the
votes brought along. Every change a node commits after its switch
record reads what the record names as in its history. The length by
which something stops counting for good is among the lengths the
snapshot and the switch records list.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
With any base followed, a coordinator could keep every snapshot at a
base of its own changes: honest envelopes then never enter a snapshot,
and lengths of time stay out of it. A check by how old a base is at
each node can part honest nodes, by when each got the decision.
A node follows only a remake whose base holds stamps of nodes of more
than a third of the voters, each written once its own history held
the epoch's threshold. A stamp's history is all its node had seen, so
such a base holds what a third of the voters' nodes had seen once the
epoch was due, and every node reads that from the base alone: none
follows where another doesn't. Without a third of the voters' nodes
stamping, no remake passes, as nothing is decided.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
left out
An envelope was taken in the epoch it named and the next, and the
root change listed what its base held of the epoch before. So a base
that left out what the epoch before had brought in sent those
envelopes two epochs back, and refused them; one user able to commit
a remake on its own changes erased whatever was signed after the
last snapshot it didn't choose. And a node away over two remakes lost
what its user had signed meanwhile.
An envelope now names the branch it was signed on: a fork or a
refusal begins one, the genesis change the first, and a remake stays
on the branch it is on. An envelope signed in an earlier epoch of its
branch is brought along from however many remakes back. What a
remake left out is kept out by floors instead of the list: for each
user and kind of statement, the highest number a remake left out; a
statement brought along at or below it, and not in the snapshot, is
refused. Every statement is numbered, votes too. A value needs no
floor: one left out names in its `prev` a value that is gone. What a
floor refuses goes to the quarantine of the node that holds it, at a
switch as on coming back.
|
| |
|
|
|
|
|
|
|
|
|
| |
"Carried over" is continuum's word for replay: a node's writes written
again by path, the last writer winning. The federated swarm does
something else after a remake: envelopes written again as they were
signed, and what each node held of them recorded. Envelopes are now
"brought along", and a node's record of what it held when it switched
is its "switch record" (`_continuum/switched/<node ID>`). The Remakes
section says that continuum's replay doesn't run under the federated
policy.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The design leaned on Automerge in places it didn't say: writers that
cost memory, one change per writer and number, changes Automerge
applies and shouldn't, the order of values written at once, maps made
at one key, history held in memory, bytes that versions must agree on.
A section near the start says what the design asks of the document,
and nothing else of it is read: changes named by their hashes, each
judged at its history; the document at a set of changes, the same on
every node; a writer for each change; history kept as long as the
store keeps it, and remakes. A section at the end says, for each of
Automerge's seven limits, what Automerge does, what the design does
about it, and what would go without it. Every rule that is there only
for one of them points to it in place. "Writer" is the design's word
for the identity a node writes under; "actor" stays with Automerge.
|
| |
|
|
|
|
|
| |
The words the glossary gets with the federated case: final, of a
decision too; stopped counting for good; the voters before; and the
alive peers and their acks, as the design names what continuum calls
the electorate and its votes.
|
| |
|
|
|
|
|
|
|
| |
"By any node" under Decisions said for votes what is now every
statement's rule; it says so in a line. And the voters no longer
remake: the row of two thirds turning says what they still can. A
matter's examples name who votes and who the roots are; and the list
of those who take part goes by who voted or signed anything that
stands, since an epoch no longer spans a term.
|
| |
|
|
|
|
|
|
| |
The design showed much and said nowhere who looks at what, nor when to
act. A section says it for each who acts, a node's operator, a user, a
voter and a root: each signal, where it shows (an endpoint, and a
metric beside it), the threshold the design recommends, and what to do.
What a node put off shows (`GET /admin/put-off`), beside taking it.
|
| |
|
|
|
|
|
|
|
|
|
| |
What every node pays was scattered over the text: what a statement, a
stamp, a cut's list and a carry record take, a snapshot a remake, a
signature's check. A section of its own says it per thing (a change,
a writer, a statement, a value, a node, a user at its limits, a claim,
a cut, a root's node, a remake, a signature), in memory, on disk, on
the wire and in time; what bounds the changes and the writers, and so
an epoch's heap (some 42 MB at the remake numbers recommended); what
nothing bounds; what was measured; what is assumed cheap.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
"A user's own claims of one name are one, ordered against others by
the earliest" left three things open. They are ordered by the first of
them that stands, by the numbers they state and then the digest, so a
duplicate committed after a release doesn't carry the released one's
witness. They count once toward the kind's limit, so a node that held
duplicates back can't commit them to push the user's later claims past
it. And a release gives up every claim of that name of its user but
those signed in sight of it, so a user gives a name up with one
release, though a node may still hold a duplicate it handed out.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Six places where a rule read a field the payloads didn't have:
* a value's envelope, with its `prev`; and since a value says nothing
of what its signer saw, where it was signed is the change that
carries it;
* `unvouch` of a user the root change holds without a creator, which
has no `create` or `vouch` to name: `for`, its ID;
* `release` of a name a decision gave or made over, which has no claim
of its holder's to name: `claimKind` and `name`;
* `firstKeys` holds its cut's `keeps`, as every cut does;
* the matter `name` names the kind beside the name;
* a member entry says which open proposals its bounds would refuse
(`refuses`).
`key` named three things in one payload; the signing key is now
`signingKey`, the key a `key` statement adds `added`, the one a
`retire` retires `retired`. And `user`, the signer's name beside its
ID, goes: nothing compared the two.
|
| |
|
|
|
|
|
|
|
|
| |
A node that comes back writes nothing before it caught up with the
peers it keeps, or `witness` passed: one number meaning two things. A
peer that delays what the node lacks for a minute had a root's node,
back from a day off, write blind. `catchUp`, recommended 10 minutes,
lets a swarm choose how long such a node waits. Past 32 heads, the
STATUS names them by a digest, so the node goes by the sync that
follows it.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A node takes a party's changes no faster than a budget, and the
design never said what the budget counts nor recommended one. It
counts changes, their bytes and their operations an hour, recommended
600, 4 MiB and 100 000 a party: a change of a few bytes that holds a
million operations draws on it too, and a change larger than what is
left of the hour is taken all the same, its party's next changes
waiting until it is paid. A node's changes draw on the party of the
user its writers count for, whatever they carry.
A root's node wrote once more for every claim that reached it, so one
party's claims and releases had every root's node write without end.
It now writes once a `witness` at most, for all claims that reached it
meanwhile: 1 440 changes a day with a minute, within its party's
budget.
|
| |
|
|
|
|
|
|
|
|
| |
Every writer costs every node 4 bytes for every change of the epoch,
those before it started too. At a year of a hundred nodes' daily
stamps, one user that starts 1 024 writers costs every node some
143 MB; 64 cost some 9 MB there, and 2.5 MB at the `remakeChanges` an
epoch now reaches. 64 writers are a node restarting weekly for more
than a year; a swarm whose epochs last longer than that (few nodes,
writing little) sets it higher, as the text now says.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A key retires itself only from where it stands, its cut holding all it
signed that the retiring change's history holds. But whoever commits
the retirement chooses that history: on dependencies from long ago a
stolen device key retired itself from there, and what its user had
signed with it since was outside the cut.
A key's own retirement now takes back nothing that a node of its user
or of a root had in its history without it, as far as an unvouch
reaches. A key above still cuts a stolen key off from before the theft.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A root's creation outlasts a cut of that root's key where another
root's node saw it, so that a root that turns can't take back settled
or final names. A thief of a root's key kept the same way every
moved-in user it gave first keys to, past the root's cut and past the
voters' too, to be undone one decision a user.
A cut a user sets (the root itself, or a thief of its key) still leaves
what another root's node saw; the voters' cut, by first keys they give
a root, takes back what the cut-off key created outside it, whoever saw
it: two thirds of the voters undo a stolen root key in one decision,
and no root does alone. With one root nobody else saw anything: its
cut takes back a name only its creation holds, final or not, as the
text now says beside the one voter.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A claim signed in sight of another that was down there only by an
unvouch or a cut is ordered against it by lateness, over all the
changes. The text counted the nodes of the other's side, the other
claimant's own among them: a claim hidden, cut off and brought back
then contested one made rightly in sight of it, and an unvoucher's own
stamp, made weeks later, brought a claim back over one made in sight of
the unvouch.
For these pairs the roots' nodes alone are the witnesses: the claimant
saw the other, and the unvouch or the cut, and said so, so neither its
own old stamps nor the other claimant's nodes count. Two claims and
Resolving say so too, the leftovers of the earlier reading go from the
"else" under Claims, and the registry shows such a claim as held while
the unvouch or the cut stands.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
Any node commits any user's statement, yet a statement still counted
only where its node committed it within that node's cut: a party that
stopped its node with a cut from before took back what the node had
committed for anyone, a settled claim among them, and an accomplice
had the name. A node's cut now takes back what the node witnessed and
the writers it started, never what it carried.
With it go the leftovers of the rule that only a user's node carries
its statements: the attack row and its test, the trust table, the API.
An out voter's node commits its carry record beside its records, and
peers take its changes for both.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The root change names, for each user it holds without keys, the root
that gives them; no other root's `create` gives keys. Two roots'
creations no longer compete, so a contest arises only where that root
signs two: they are ordered as claims are, with the other roots' nodes
alone as witnesses, so a twin on old dependencies is late for good once
another root's node saw the first.
Which creation gives the keys is read over all the changes, as which
claim holds a name is, and no longer where each statement was signed:
read there, a twin was the only creation at whatever place its maker
crafted, and its keys signed as the user. While two contest, nothing
signed with the keys of either counts, until the voters give first
keys; what the keys they give signed counts then. A decision on the
roots that leaves a root out says which root gives the keys it was
named to give.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A federated swarm remakes as every swarm does: a node proposes and
coordinates, the alive peers ack, every node builds the next epoch
itself. The voters no longer decide remakes, so the base check, the
votes naming a base, `baseAge`, `remakeAge`, the heal, and the admin
actions `choose`, `follow` and `back` go. What the federated policy adds:
* compaction only, and no sooner than the epoch's history holds
`remakeChanges` changes (recommended 10 000) or its changes started
`remakeWriters` writers (1 000): every node proposes and acks by
these numbers, and follows only such a remake;
* any base serves: the snapshot holds the registry at the base with
whatever something signed later could still change (envelopes with
their signatures, what was given up and hasn't stopped counting for
good, what the order among claims rests on, how far each length of
time has run), and every node carries over what it holds beyond the
base with what it held of it;
* envelopes of the epoch before come from any node, as within an
epoch; a claim carried over and one the snapshot holds are ordered
as two claims out of each other's sight, not by the base;
* lengths of time go on across a remake, each node's carry record
saying what it saw broken after the base;
* of two remakes of one epoch, every node goes to the one with the
lower ID.
A remake made a cut reach no further back than its snapshot. With
remakes as frequent as the document grows, that would leave a stolen
key's work standing after an hour. So what was given up, replaced,
left out by a cut or past its limit, and was seen so for `final`, has
stopped counting for good, remake or not; that is what a remake leaves
out.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
A remake no longer names the voters and the roots: each is a matter the
voters decide, as a number is, and holds until another decision of it.
Whether a user is a root is read where each thing it did was done, so a
decision changes nothing done before it.
What the votes of before could still do once others vote, a remake used
to put out of reach. Two rules do it now. A decision of voters that a
decision on who votes replaced counts only where that decision's
proposal was signed in sight of it decided. And a decision seen holding
for `final` is final: no decision of its matter whose proposal wasn't
signed in sight of it holds instead, whatever its number.
|
| |
|
|
|
|
|
|
|
|
|
| |
The design named fields in passing and listed none, though stage 2 settles
the payloads first. A section lists the fields each rule reads: every
envelope's (swarm, epoch, path, kind, signer, what it saw, its number, the
key and signature), each statement kind's, a proposal's matter and what it
holds (a remake's switch delay among them), a vote's; a fork's vote,
which counts toward no matter; and what a node writes plain: a record of a
proposal, a carry record, a member entry with the user its writers count
for and the digest it computes.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- What an operator says, listed with each action named where it is used:
rejoin, choose (two remakes decided, or a walk through the archives
that ends elsewhere), follow (a node that waits past `remakeAge`), back
(refusing the remake), fork, refusing and bounds, dropping what the
others refuse, accepting a check of itself that differed, taking what
was put off. Tokens from the nodes `--token-nodes` names.
- Where a cut takes a thief's node's writers off a user's count, below the
limit again, every node takes what it put off for that user, nobody
acting. A writer counts for the user it was counted for until such a cut.
- Caught up: the heads each peer kept had when the node reached it, as its
first STATUS says, or `witness` passed; a peer that keeps sending keeps it
silent no longer.
- A fork's base: rule 4 takes its proposer's node's record, without votes;
it refused it unless two thirds voted for the fork.
- Relays: each node's configuration in a federated swarm; nobody may write
`_continuum/relays` plain.
- In the open: `GET /registry/users/<name>` shows which root's node keeps a
user in past an unvouch or a cut, and which roots' creations contest a
moved-in user's first keys.
- A carry record names what counts through a cut, as through an unvouch.
Two rows move to the stage of policies changing: a limit lowered and raised
again, a stamp between.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- Going back by an operator's word refuses the remake: the heal doesn't
move such a node again. A node sent back followed again once the count
crossed a third, and what its users had signed again came along beside
what they signed in the new epoch: two users of one name. Meanwhile
neither epoch decides what takes nodes of more than two thirds of the
voters; a node moves on by word.
- Every node takes a base up, and counts `remakeAge` from then; a node of
no voter notes when, and builds the snapshot only once the remake is
decided. Taking a base up chooses nothing. A node of no voter had no
clock, and a remake shown long after its time would have taken it.
- Every node that switches commits a carry record, out voters' nodes too:
the heal's third is of all the voters.
- A node that waits asks a peer in the new epoch for its carry records
once, when they connect, and is pushed each one the peer takes after:
nothing is polled. Stage 14 builds it.
- A carry record speaks for the epoch it leaves: its roots witness, a third
of its voters say what was seen for long.
- The proposal names its switch delay; one naming no root is no proposal;
a moved-in user's contested creations go along in the snapshot. Who
undoes an unvouch's witness, and how far back. The malicious choose when
the count crosses, by their own records: said.
Attacks: a late remake against nodes of no voter; back and forth by a
split that stays.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- A claim made in sight of another that didn't stand there only by an
unvouch or a cut is ordered as claims out of each other's sight, over
all the changes. Judged within the history its signer chose, a creator
that cut its key off from before the creation, on old dependencies,
then claimed the user's settled names there, found no witness: the
user's claim gave way for good, no root taking part. The roots' nodes
that had the user's claim count first now make the new one late; a
root's node witnessing after the fact makes both late, a contest. The
exception for a root's witness of an unvouch goes.
- A moved-in user's first keys are read where each statement was signed,
the roots' creations ordered first, by the roots' nodes alone (a user's
nodes carry for it by the keys these decide). Read over all the changes,
a root's twin on old dependencies took back everything the user signed;
now it freezes the user until the voters say, and takes nothing back.
- A root's creation another root's node had seen before the cut stays the
claim of its user's name, and a moved-in user's first keys. A root that
turned took its creations' names, final ones too, where only the roots
create users; now only what the other roots hadn't seen. A thief of a
root's key keeps what it created in their sight, for the voters.
- Any node commits any user's statement but a `node` statement: which node
commits one, or whose, says nothing of it. A user's own claims of one
name are one, whatever node they came by.
Attacks: a creator's claim in sight past its cut; a root cutting its
creations; a root's twin taking back what the user signed; a claim through
any node. Rows 7, 9 and the new twin row move to the stage of claims out of
sight.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- No root releases its `create` for a user the root change holds. Allowed
while it contests another root's, a root made its own contested by a
twin on old dependencies, or signed the release on old dependencies once
it was final, then gave the user keys of its own: nothing the user
signed counted any more, final names included. Two roots' creates
contest until the voters give first keys.
- A root's node witnesses past a cut, as against an unvouch. With only the
signer's nodes, a creator that turned cut the creation's key off from
before it, its nodes silent, and nothing its user signed counted: an
accomplice took the user's settled names. A root's node that witnesses
for a thief's sock keeps it in, in the open; said under what is not
promised. A carry record witnesses for a vouch or a creation cut off as
for an unvouch.
- The heal of a split by `remakeAge` counts a node for one voter, of the
voters of the epoch that decided the remake, each carry record as it
stood where written; a node that waits fetches them from peers in the
new epoch. A node that followed goes back only by its operator's word,
and the heal moves only nodes that wait by `remakeAge`, not one whose
operator refused the remake. The malicious could steer whether a split
healed forward or back, and send the honest back and forth, each time at
the cost of what their users wrote; they choose when a split starts,
and no more. Argued under why it holds.
- Said: own-name claims where only the roots create users, and under a
rule a decision changes; a `remakeAge` of nothing ends remaking; the cut's
price with the same witnesses; which member entry a writer counts by;
screening's generated changes among what is assumed.
Attacks: a creator's backdated cut with its nodes silent; a root's twin
`create`; a heal steered by carry records held back or taken back. Rows 8,
96, 105 and 106 and row 129's test name mended.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A remake shown when some honest nodes are past `remakeAge` and some aren't
split them for good: those within followed, those past stayed, their
remake votes spent.
It shows on both sides now (those that wait hold the decision and see
peers in the new epoch; those that followed see peers in the old one),
and heals by the new epoch's carry records, which every node reads alike
and which only grow. A node past `remakeAge` waits in the epoch instead of
staying for good, and follows once they count for more than a third of
the voters: a node of an honest voter got the decision in time, and the
malicious alone count for less. While they count for no more, a node that
followed goes back `remakeAge` later, dropping the new epoch as a node
comes back from changes the others refuse, its users' writes there
quarantined to be signed again; should they cross a third later, it
follows again. Every honest node ends in one epoch, and a remake shown
long after its time is followed by the malicious alone.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
How late a remake its node follows was each operator's bound, by its own
clock: operators set different bounds, and nodes take a base up at
different times, so a remake shown when some honest nodes are past their
bound and some aren't splits them between two epochs, those that stayed
with their remake votes spent.
It is a number of the policy now, `remakeAge` (30 days recommended): how
long after taking its base up a node still follows a remake. The bounds
no longer differ by operator; that nodes take a base up and get the
decision at different times remains, and with it the split, said under
what is not promised and in an attack row. The bound isn't read from the
changes, and a remake past it doesn't free its votes: a deciding change
built on old dependencies always looks in time, so the remake could still
be decided beside the one its voters then voted for.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- A root releases its `create` for a user the root change holds only while
it contests another root's. Released at any time, it took the user: none
of its keys stayed its own, nothing it signed counted, final names
included, and the root gave it keys of its own.
- A node's writers count for the user its member entry names, its own word,
carried over a remake with the entry; the lowest digest of a `node`
statement only where it names none. By digest alone, after a remake, any
user the node carries for could make itself the node's, by signing until
its digest was the lowest, and have the node put off as a whole.
- A user's claim of its own name is valid only where a rule of the kind
`user` would let the user create that name: a name kept for one creator's
creations goes with that creator's cut, as the attacks said.
- Past a cut, only the signer's nodes witness what a vouch or a creation
carried, not a root's: a root's node could keep a thief's sock in for
good, committing with a fresh writer on heads without the retirement. An
accomplice's vouch keeps a sock in; said under what is not promised.
- Clients offer a vote for one of the remakes under way that name the same
voters and roots (most votes, then the lowest digest), and none for a
proposal whose coordinator named two bases; that one voter can still
split honest voters signing within the same minutes is said.
- A snapshot built for every remake's base is among what an epoch costs.
- What screening refuses: tables and marks, a deletion named as replaced;
the test that generates changes.
Leftovers: decided, for a remake, in Decisions; rows 60 and 93 to the
stage of unvouching. Attacks: a root releasing its `create` after its user
signed, a user making itself a node's across a remake, a twin remake, a
root's witness past a cut; row 130 with the three kinds screening refuses
now and their tests.
|