| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Remakes. A node took up the first base it saw and no other, beside votes
that name their base and are never released: two remakes proposed at once,
or a base handed first to nodes back from away, split the nodes, and a voter
whose nodes took one base up could vote for no other, ending the epoch's
remakes with nobody malicious. A node now takes up every base that passes,
one record a proposal; records count toward taking a base up however old
without votes, and a remake's record is judged without them (as written, a
record needed votes in its history that come only after it). Clients offer
a vote only for a base whose records count for more than two thirds of the
voters, showing the other remakes under way. The votes alone keep two bases
from both being decided. What votes never released cost is said under what
is not promised: voters who split end the epoch's remakes, and whoever
holds a hanging remake's last record chooses its day; an operator bounds
how late a remake its node follows, and refuses a later one by staying. A
remake's vote runs while the epoch lasts, and the voters don't end it by a
later proposal; said where every vote was said to.
Writers. A node carrying for several users counted its writers for each,
so one user past its limit put off every node that carries for it, for all
their users. A node's writers count for one user now: the first that named
it, as its own changes show.
Names.
- A creation or vouch cut off stops counting as its signer's unvouch would,
from where the cut was set: a user only its creator vouched for is out
from there, its names waiting, final ones too, until it is gone or a vouch
comes. Before, everything it signed stopped counting at once.
- A root releases its own `create` for a user the root change holds: two
roots answering at once contest, and nothing ended it.
- A `create` is refused where a user's claim of its own name holds the name,
and a user has one such claim at a time.
- A root's witness outside a claim's history makes two claims contest only
where it had the other count through its own witness of an unvouch, as
meant: a limit lowered and raised again leaves sight to decide.
- What comes back over a later claim is said for a holder's own release,
limit or cut too.
Attacks: two remakes proposed at once, a remake held by its last record, a
node carrying for a user past its writers, a creator cutting off a user
only it vouched for, a crafted first change of a writer in a batch, a user's
own name claimed again; row 124 with what transactions never write and the
tests that show it. A limit lowered and raised again moves to the stage of
decisions, a witness after an unvouch to unvouching. What was checked: the
committer is named from a change's own history.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The third reading against the text and the code:
* A remake's base: the coordinator names it, a voter's vote names it,
once an epoch, never released, and a record counts for a voter only
where its vote names the record's base. A coordinator handing two
bases to two nodes of each voter gets one decided or none. A base
whose records count for a third of the voters every node takes up,
however old: a partition at the base no longer ends the epoch's
remakes.
* Whether a claim stood where a later one was signed is read with
the witnesses in that history; one made after brings nothing back,
and a root's makes the two contest. A claim pushed past its limit
by statements a cut leaves out comes back, as one released by a
stolen key does.
* A user claims its own name with its own key, which holds the name
where its creator's key is cut off from before its creation.
* A decision on whose a name is makes every other claim give way,
two final ones too.
* A root's creations giving keys to a user the root change holds are
ordered as claims: one root coming after another gives none.
* Writers are counted per user, as settled; a twin switches a node's
writer only signed with its key. A node keeps when it received what.
* Leftovers: an out voter's records taken from its nodes, the lists
of a cut, the encoding among what can't change, a change's
operations among what isn't bounded, stages, words. 129 attacks.
|
| |
|
|
|
|
| |
"Root" meant both a user and an epoch's first change. The first is
now always the root change. The budget's test goes with the budget
(stage 8), and a crafted change's tests, which exist, with stage 1.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The questions the design left:
* A cut that takes back an unvouch brings its user in again. Its
claims from before stood all along; what it signed while out comes
to count later than it was signed, and gives way to what was
claimed in sight of it. Gone stays gone.
* A creation taken back by a cut is taken back as a vouch and as the
claim of the user's name, not as the user: a vouch names a user by
its ID, so with another vouch the user stays in, keys and claims,
without a name.
* `prev` names the value that shows where the envelope is signed;
where several count there, any one of them, and the write replaces
them all.
* A carry record needs telling from no other change: it witnesses by
what it names. A remake's proposal isn't carried over.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What was left open after the second reading:
* After a remake every node first commits a carry record: the digests
of what it holds beyond the base and what it held of it. It
witnesses as the node's changes did. Then each envelope is written
again once, by whoever finds the epoch lacking it, and only where a
carry record names it. So a late remake doesn't bring every
envelope once per node, and nobody hands in later what no node
held at the switch.
* What is carried over comes after what the snapshot holds and before
what the new epoch signs: a number nobody could check orders only
its signer's statements, and a carried proposal outranks none of
the new epoch. A value of the new epoch has the last word over one
carried over.
* No node takes up a proposal that says it saw less than the node
held a window before, so whoever proposes can't make refusing cost
a whole epoch.
* A node stops writing only where its digest differs from the nodes
of more than two thirds of the other voters: fewer than a third
stamping nonsense stop nobody, with three voters too.
* A node carrying for a third of the voters, keeping its records back,
is said, with what the voters do about it; a voter without a node
names carriers of two parties.
* Writers of a node stopped with a cut count for nobody. A limit
lowered for a day gives names away for good, said.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
The design asks that an honest federation bears whatever the
malicious do, and rules nothing about a party's own nodes, which
nobody could enforce. So:
* Bans go: `ban`, `--follow` and their limit. Leaving a user out when
reading is each reader's own, and a side note.
* Whom a node lets in and what it lets them do is its operator's.
Keys in the registry give nothing on a node by themselves.
* A remake that leaves a root out says which root has each name a
rule gives a root, so none is without a holder.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The design after a second reading against itself and the code:
* An epoch has one remake: a voter's node records one base for its
epoch and no other, and a later proposal is taken up only for that
base, those voters and roots. No node that switched moves again by
itself. The proposal lists the voters by their IDs and names its
coordinator; nothing after it is signed changes the list.
* A voter votes for its epoch, in, out or gone, and the nodes of one
that is out commit their records and nothing else. A node takes up
only a higher number than it took up. A record is read where it was
written.
* Of two claims, one signed in sight of the other: sight decides
alone, asking whether the other stood where the claim was signed.
Late is asked only where neither saw the other, and a claim late
against one that isn't late against it is late for good. A final
claim gives way to none but another final one. An earlier claim
comes back over a later one only where a root's node had seen it
hold the name before it went down.
* What was given up or is left out by a cut comes before nothing, so
a stolen key's statements stand in nobody's way once it is cut off.
* A retirement lists what its cut keeps, so the cut holds after a
remake. After a remake a node states what it held of what it
carries over (which claim late against which, what counts through
an unvouch, which value replaced which), where an order of changes
said it; of several values at one place, one that another replaces
is left out. The snapshot keeps the proposals that are open.
* Giving a user up puts it out, and it is gone after `gone`: a cut
takes it back until then. First keys for a user the root change
holds are given once.
* Writers are counted by a party's budget and put off past
`limits.writers`, never refused. A party, for a budget, is a user
with the users only it leads to.
* A node that follows several users takes a ban where most of them
state it. Between two stamps is read from their histories. The
relays stay an operator's list.
* What is asked of a change before Automerge sees it, as the code has
it. 121 attacks.
|
| |
|
|
|
| |
`limits.writers` is recommended at 1024. A user whose nodes started
that many starts no more until a remake; how many they started shows.
|
| |
|
|
|
| |
Screening refuses them in every swarm, so the design builds on it and
no stage adds it.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
An actor that is the hash of its change with the actor left out makes
a fork of an actor two changes that every node holds: it can be made
with Automerge 0.12's API and is checked with one hash. But Automerge
keeps a slot per actor in every clock it caches and moves its indices
for every actor that comes, so with an actor per change heap and time
grow with the square of the changes: 32 to 257 MB and 2 to 20 ms per
change applied at 10^4 changes, 2.7 GB and 0.16 s at 10^5 (measured
with Automerge alone). A hundred nodes stamping daily write 10^4
changes in a hundred days.
So a fork of an actor stays proven and named, not prevented.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A writer (an Automerge actor) costs every node heap in proportion to
the document's history: about 4 bytes per change, a slot in each
clock Automerge 0.12 caches. A document of 10^5 changes takes 42 MB
with 10 writers and 435 MB with 1000 (measured with Automerge alone).
Screening counts no actors, so a party starting a writer with every
change adds gigabytes to every node.
`limits.writers` (256 recommended) bounds what a user's nodes start
in an epoch, judged as a change's history shows, and a federated node
keeps its writer over a clean stop. Out of each other's sight such
writers are valid and held: the nodes that made them are refused as
peers, a party's budget bounds how fast they came, a remake leaves
them out. Not promised: a bound on what an epoch's document costs.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Automerge 0.12.0 applies changes no honest node writes: one that
lists an actor none of its operations names, one whose first
operation is numbered below its dependencies' or at 2^32 - 1. It then
gives back another change than the one it was given, saves a document
that doesn't load, or panics (measured with Automerge alone). A party
that crafts one stops the honest nodes, where a forked actor only
parts them.
So a change is refused before Automerge sees it unless its bytes are
the ones Automerge encodes for it, every other actor it names has
changes in its history, and its first operation is numbered one after
the highest of its dependencies. An attack with its test, in the
first stage.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The design as it stands after being read against itself and the code:
* A statement says where it was signed: its payload names the changes
its signer saw. "In sight of", the order past a limit and a
proposal's number are read from that, so carrying a statement a
second time moves nothing. A statement that is counted states its
number.
* A node carries for a user once it committed the statement naming it
itself. Tokens and logins by key are taken as a node's operator
says.
* Lines say who is in and nothing else. A claim's witnesses are its
user's nodes and the roots'.
* The roots are several, named by an epoch's root change like the
voters: by the genesis change, then by each remake. What a root
signed for another is the seats' once its signer holds none, and
the roots take that back only together.
* A claim seen holding its name for `final` by a third of the voters
is final: no rival holds or contests the name after, whatever a
root says and whatever is cut off. It takes no root.
* A claim made in sight of one that didn't stand doesn't give way to
it when it comes back (its user vouched for again, a limit raised);
only a release or a cut that a cut takes back does that, until the
later claim is final. Late is witnessed by a change that saw the
other stand while the claim didn't.
* A cut never leaves out its own statement, and takes back what the
key it cuts retired, stopped and unvouched. Giving a user up takes
a first key.
* Every voter counts toward a decision: more than two thirds of all.
Nobody is absent; a remake names those who take part, and a voter
votes while it isn't gone. Any node of a voter takes a proposal up;
every node judges a record against the votes in its history; a
proposal is decided at a record that has two thirds of them in its
history. A node takes up nothing lower than it took up, the highest
number holds, and what hangs short of records shows and is ended by
a later decision. A change is judged by what is decided in its
history; the registry is resolved by what holds.
* What is decided: numbers, the policy, first keys, the names of a
user that is out, whose a contested name is, the voters' names, and
a remake with the voters and the roots it names.
* A remake: every node carries over what it holds beyond the base,
whoever signed it, in its first changes and in order; the root
change lists the digests of the base's statements, so nothing it
left out is written again; decisions after the base are taken up
again, and what a third of the voters' nodes held as gone, final or
dropped stays so. An epoch's remakes are one matter.
* A kind may name the characters of its names (lower case
recommended); a kept name may be claimed, to stay through a change
of policy.
* The genesis change may hold users, without keys too, so a registry
moved in has its users from the first change.
* How often nodes stamp, a member entry's size, and what the genesis
change sets for the swarm as a whole are numbers of the policy.
* A node compares what it resolves with the stamps of the voters'
nodes, and stops writing only where a third of them differ. Two
wire versions spoken at once is a change for every swarm.
* Stages: versions before remakes; the registry stage is for trying,
the last for relying on it. 110 attacks.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A remake that names all users names those that count in its
proposal's history, and still do at its base: the list is fixed with
the proposal, so those who vote see it, and a user brought in while
the votes run isn't on it. A fork's voters go the same way.
And what reading the design from end to end found:
* a remake does two things, not one: it throws history away and names
who votes next;
* nothing plain is written but a node's member entry and its records
of proposals, said where namespaces are, too;
* a node doesn't sync under a policy it doesn't know, whatever its
version says;
* two sides that only resolve differently show by their stamps;
* on the wire a federated swarm's handshake says which epochs a node
keeps, and a version speaks the one before its own: "no message
changes" holds for a swarm that isn't federated;
* three more things assumed: what was seen for long kept as the node
goes, the cost of a digest with every stamp, two wire versions
spoken at once.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the maintainer asked of the design:
* Who votes is named by the remake's proposal: all users at its base,
as recommended, or a list. So those who vote say who votes next,
and nobody votes by a rule of who created it. What that costs is
said with it: every voter named counts toward what a decision
takes, and all users is whoever brought users in.
* What a policy no longer covers is uncovered at once where the
decision holds: shown aside by every node, taken away by its user
only, changed by nobody, and dropped once it has been seen there
for `uncovered` (a number; 0: at once). Within an epoch a rule
moves nothing in the document; the remake moves it.
* Being seen takes nothing but a node that is up: its stamp is
renewed about daily whatever else is written. A node left running
keeps its voter present; naming the voters deals with that.
* A release of a vote is best effort.
* Continuum changing under a swarm: versions agree by what they
compute, not by a number. Every stamp carries the digest of the
snapshot its node would build there; a remake is taken up by the
ID each node built; a node checks itself against the swarm before
it writes with a new version; a change of the rules is a change of
policy, and a node knows a policy by everything in it; recorded
vectors every version passes. What can't change, what changes
freely, and when it is a fork.
* Who may connect is outside the design; the swarm key is a note.
The attacks are 84.
future-work.md: several roots, present by the user's own signature, a
guide to moving to another swarm.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the maintainer asked of the design, and what it changed:
* Lines. A user is in while it has a line: a chain of creations and
vouches from the root. When its creator goes, one that another
vouched for stays without doing anything. The witnesses of its
claims are the users on the lines it stands on: its creation's, and
those of vouches it accepted (`accept`), so nobody gets a say about
a user's names by vouching for it unasked. Why only its signer
takes a vouch back is said where unvouching is.
* Lengths of time are read between two stamps of one node, with what
that node had seen at each: a voter is absent once a third of the
voters saw it silent for long, a user gone once they saw it out. No
clock is set against another, and why a third.
* Decisions. A proposal is decided as soon as the nodes of two thirds
of the voters hold its votes: at once, not at the end of a window.
Any number are open at a time, within a limit a voter. Of the
decisions of one matter the last holds, by which proposal was made
in sight of which, so two decided at once stop nothing. A remake's
base is named by its coordinator, a node of the proposer.
* The policy changes by a decision, as a whole, with no remake: a
remake throws history away and does nothing else. What a policy no
longer covers doesn't count, and a remake keeps it aside for an
epoch or drops it, as the policy says. Going apart by a fork stays
for those a decision leaves behind.
* What a remake leaves out, so that the document's size goes by what
stands: a release is a statement in its epoch, the remake deletes.
* Names are written as they are used, in the document and in the
rules alike, and compared by their segments: structure, not
meaning. A rule may leave a name to the voters to give.
* Who vouched for whom changes nothing in who connects to whom: a
node keeps its seeds and its user's other nodes as neighbours.
The attacks are 83, the stages fifteen.
future-work.md: guides to write (keys, the root, starting a swarm,
voting, a registry), policies merged.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the maintainer answered to the design's last two questions, and
what follows from it:
* The fractions are numbers of the policy like the others, changed by
a decision to any value: the share of the voters present a decision
takes (two thirds recommended), the share of all of them (half), and
the share whose stamps make the swarm's time and a user gone (a
third). What is promised of decisions is argued for the recommended
ones; Why it holds says what other values carry.
* Refusing a decision: a node follows every decision that counts
unless its operator has it refuse, by bounds on the policy's numbers
or by hand. It then moves to the epoch built at the decision's
history without it, which is the same for every node that refuses
the same decision: those who think alike go on together without
arranging it. While a proposal's votes run, a node whose bounds it
breaks says so. A remake or a change of policy is refused by
staying.
* A decision gives a user name with its namespace, as designed.
* No open question is left. The options not taken that the questions
listed are among the roads not taken: first users voting as soon as
created, voters let in without a remake, other reaches of an
unvouch, a gone user coming back, first keys by those who vouch,
a registry of only what is signed, numbers the design fixes.
The attacks are 78; the stages name them by their numbers.
future-work.md: bounds on more than numbers.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the maintainer answered to the questions the design had left:
* Every quantity of the design is a number of the policy, in one
table with what the design recommends (the times, the limits, how
much a remake's base may lack, how long the root's node lets a claim
wait). The genesis policy sets each, and a decision changes any to
any value: nothing constrains them. The fractions aren't numbers.
* While a user is out, the voters free its names or give them to
another by a decision, whatever `gone` says; a policy without `gone`
has the names wait until a vouch or a decision.
* Nobody is put out by a vote, said where unvouching is, with what
there is against a user that harms within the rules.
* A node keeps the epochs it left for as long as its operator says,
`archiveRetention` at least, and says which; so a node coming back,
or one joining from the genesis root, walks every epoch where an
archive is within reach, and shows where the walk doesn't end at its
peers' epoch.
* Settled, and listed so: who votes, from where an unvouch undoes,
gone for good, first keys by a decision, what the root holds
unsigned. Two questions remain: whether the fractions are numbers
too, and whether a decision gives a user name with its namespace.
future-work.md: an archive of every epoch.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the maintainer answered to the design's open questions, in the
design:
* The numbers. The limits and the times are the policy's numbers, set
in the genesis policy and changed by a decision: 64 keys, 64 nodes
and 256 addresses a user for a start; `window`, `absent`, `gone`,
`archiveRetention`. A lowered limit takes nothing away.
* A user nobody vouches for is out, and its names wait for it: nobody
else claims them. Out for 30 days, as the stamps of a third of the
voters show, it is gone: its names are free, and no vouch brings it
back. So whoever relied on a vouch that an unvouch or a cut took
back has that long to find another, and loses nothing meanwhile.
* First keys by a decision. The voters are above every user's first
keys: they give a user that lost them new ones, with a cut for the
old. The promises say so, and what isn't promised: a name against
two thirds of the voters.
* What a decision is made of (a proposal, a vote, its release, the
decision) is taken in any node's change, so a user without a node
votes at whatever node it reaches, or by a vote carried to one. Such
a user names another party's node to carry for it.
* Coming back after remakes: by the archives on nobody's word, epoch
by epoch, as far as peers keep them; else by an ID the operator
gives, never because peers advertise an epoch. A statement is
carried over from the epoch before only; older ones are quarantined
for the user to sign again.
* Resolving reads the decisions first: nothing below changes them.
* The questions that remain are put with their options: who has a
vote and from when, whether the voters put a user out against those
who vouch for it, from where an unvouch undoes, whether gone is for
good, the price of first keys by a decision, and what the root
holds unsigned.
The attacks are 76; the stages name them by their numbers.
future-work.md: barring a user by a decision, and voting made easy for
a user without a node.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
federation.md designs what the krebs registry needs of continuum: a
swarm several parties keep, any of them possibly malicious. Nothing of
it is built. It is a mode a swarm is started in: one that isn't
federated stays as it is.
* The parties, what an adversary can do, and what is promised to an
honest node: only valid changes; the same document and the same
resolved registry for the same changes; values signed by their users;
one holder per name; a claim nobody takes once the root's node saw
it; no waiting for anyone to write; and, with fewer than a third of
the voters present malicious, decisions by two thirds of them. And
what isn't: one history under a partition, a name never contested,
decisions against a third, against keys stolen later, against a
malicious voter on both sides of a long partition, or with half the
voters gone; a swarm no forked actor splits.
* The design, on the strict policy. The policy is in the root. Users
come by statements that only add; a user is its creation, its keys a
tree, its nodes those it names. Vouching and the line; unvouching,
with what exactly it takes back. A namespace per user. Names of
declared kinds claimed, with rules and limits as data, some kept for
a user without a claim. Of two claims out of each other's sight, one
is late where its own side can be shown to have seen the other
first; where that leaves not exactly one, the name is contested, and
a release gives it up. Cuts: what a key signed outside a set of
changes stops counting, whenever it shows up; a key is cut off by one
above it only. Bans change what those who follow read, not what
anyone takes.
* Decisions: votes signed by the voters, over days, by numbers the
document holds and a decision changes. Who votes is in an epoch's
root change: the root alone at first, then, with each remake, the
users a root created, so nobody fills the votes without two thirds
of those there agreeing. A time read from the document, by which
those away for long don't count; a decision taken up by the voters'
nodes while its votes run, and counting with two thirds of those
present and more than half of all, so that honest voters never make
two however long a partition lasts. The
root's seat given anew by a decision, and what a root finds when it
comes back. Remakes: the base is the decision's history, every node
builds the snapshot from the registry as it resolves, statements are
carried over, and what counted at the base is final. A change of
policy as a fork each operator follows or not, as Bitcoin changes
its rules; it may name who votes on its side, and is the way out
for those a decision leaves behind.
* What every node judges and how the registry resolves, how a partition
shows and how a side comes back, links along the line, tokens of
one's own party only. Why the promises hold, the roads not taken,
what members are trusted with then, what is continuum's and what the
application's, 69 attacks with the tests that show them, the
registry's layout with moving in and writing out, fourteen stages,
and ten open questions with a choice for each.
future-work.md gets what the design leaves.
|
| |
|
|
|
|
| |
The glossary and the `kind` row of `remakes.md` named three kinds of
remake; `strict` is the fourth, and takes `baseHeads` as `replace` and
`import` do.
|
| |
|
|
|
|
|
| |
The example of a strict policy wrote it through the API, which every
node refuses where the policy isn't strict: a swarm turns strict only
at its start or through a strict remake. It shows the genesis node
given the policy, with its first user and their key.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The policy was read in typed JSON, so that an Automerge text spelling
"signed" at its `values`, which no operation `rules::turns_strict` asks
of writes, turns no swarm strict. But that read every policy anew: a
setting that wasn't a string, or a text at `signatures`, made a policy
no node knows in swarms that aren't strict, which read it as before.
The policy is read in plain JSON again, as it was, and only its
strictness asks more (`policy::of`): it reads strict only where its
`values` is a string in typed JSON, an envelope read as its payload.
A policy that would read strict only through a text, at `values` or
holding the policy, is one no node knows. Every policy that doesn't read
strict reads as it did.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A swarm turns strict only at its start or through a strict remake, and
a change writing a strict policy where the policy isn't strict is
refused, found by its operations: `"signed"` put at the policy's
`values`, or an envelope asking for it put at its place. But the policy
was read in plain JSON, where an Automerge text reads as a string, and
writing a text is no such operation: `{"$text": "signed"}` at `values`,
through the typed API, turned a swarm strict that nothing refused, with
a time before it nothing closes.
The policy is read in typed JSON now (`store::read_plain_as`): what
continuum writes there reads as it is, plain JSON or an envelope, and a
text, a counter or bytes as itself, tagged; a setting that isn't a
string makes a policy no node knows (`policy::read`), as a version it
doesn't know does. So no text turns a swarm strict, and the operations
`rules::turns_strict` asks of are the only ways to. A policy holding none of these reads
as before.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
Under a strict policy, links and other writes go by where their change
is among those replayed, and of one change the links went first. Both
were judged at that change's history, without the other; a link can
only take away there what the other writes relied on (a capability
revoked), never give what they needed, so they go first now.
A group of other writes was placed by its last change by history but
named the user of its newest by clock; it names the user of the last
by history now, as it goes.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A strict policy written into a running swarm left a time before it:
changes written there, beside the turn, were refused by the nodes that
took the turn first and taken by the others where they came first (a
signed policy that isn't strict, among them, unseated the turn there);
and a remake whose base preceded the turn had every switching node
replay the turn as one of its own, each refusing the others'.
A change writing a strict policy where the policy at its history isn't
strict (`"signed"` at its `values`, or an envelope there asking for
signed values) is now refused, in every swarm. A swarm turns strict at
its start (`--bootstrap-policy`) or through a strict remake, each its
epoch's first change: no change of a strict epoch is from before its
policy, and the rule for the time before goes, with the walk that found
the changes that turned a swarm strict and what kept them
(`before_strict`, `turned_strict`, `Reads::strict_now`,
`Reads::turned_now`, `store::writers`, `store::made`,
`changes::in_history`). The strict swarm's simulation starts strict.
access.md says so, and that a strict swarm can't move to a policy its
nodes don't know by writing it.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
`--genesis --remake` writes the content as a change of its own before
the one recording the first users and `--bootstrap-policy`. With a
strict policy, that content change was a time before the policy, on
which any member could build a change judged by none.
A strict `--bootstrap-policy` with `--remake` is now refused: a swarm
strict from its start starts empty, and one started from content turns
strict through a strict remake, which keeps only what an operator
looked over. A policy that isn't strict starts from content as before.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Under a strict policy, the links of the chains to signed values went in
the order their changes were made, but the other writes were grouped by
time, and a link went before a group only where its time wasn't later.
A write built on what a link grants (a capability in an entry its
manager signed, a ban lifted, a declaration) went first wherever its
clock was behind the link's, was judged where it wasn't granted yet,
and was quarantined, though every node had taken it.
Under a strict policy the other writes now go by where the last change
that wrote them is among those replayed (`between`), with the links,
and keep their times for later replays. Without a strict policy there
are no links, and the groups go by time as before.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A strict policy could be written over with one that isn't, or deleted,
by a user who may manage the policy. While the swarm was relaxed so,
nothing was asked of the time before it turned strict: a change written
beside that turn was taken, and once the swarm turned strict again,
built on, a node judging that change while strict from the first turn
(one back from away, a joiner) refused it, and every node it told
dropped it with the second turn and everything after.
Under a strict policy, the policy is now written again only as strict:
an envelope there whose value isn't a strict policy, a signed `null`
among them, is refused. So a strict swarm has one change that turned
it, and the time before it stays closed; to leave it, start a new swarm
from its content. A swarm that isn't strict writes its policy as it
did.
|
| |
|
|
|
|
|
|
| |
`--bootstrap-policy` records the policy in the genesis change, "no
change of it from before the policy". With `--genesis --remake`, the
content is a change of its own before the one recording the users and
the policy. access.md says so, and that a change built on the content
beside that one is refused as from the time before a strict policy.
|
| |
|
|
|
|
|
| |
Where the new epoch holds as high a `seq` at a signed place as the old
one reads, the chain isn't replayed: it was counted as superseded and
left out even with `--superseded-writes quarantine`, unlike every other
write a newer one superseded. Now it goes to the quarantine then too.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Under a strict policy, the links of the chains to signed values were
ordered across places by their changes' timestamps. How a link is
judged in the new epoch depends on what was replayed before it: a key
added to a user's entry, a capability granted. A write signed with a
key added a moment before, through a node whose clock is behind, went
first, was refused and quarantined, though every node had taken it.
The changes replayed (`between`) now come each after those it builds
on, clocks deciding only between changes neither of which saw the
other, then the lower hash; the links follow that order, and an
envelope takes its time from the first change that wrote it there.
remakes.md says so, and what becomes of a place where a link is
refused. Without a strict policy there are no links, and nothing
changes.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A change written under a policy that isn't strict was refused, in a
strict document, unless it was in the history of the change that wrote
the policy value the document read now. So the policy written again by
a node that held a change from before, taken beside the strict policy,
put that change in the new writer's history: that node kept it, every
other node refused it, and the new policy with it, and the node was cut
off.
Now the reference is the change that turned the swarm strict: one that
wrote a strict policy where the policy at its history wasn't, found by
following back the writes of what the policy holds
(`store::writers`). A change written under a policy that isn't strict is
refused where such a change is beside it, neither in its history nor
built on it. A policy written again, strict over strict, names the same
change.
One turning the swarm strict beside it is refused like any other. Of
two at once neither is preferred: any rule choosing one, the lower hash
say, would let a change made later to look as old take the place of the
one every node took, and every node would drop it with all that was
built on it. So two members turning a swarm strict at once split the
nodes that took one from those that took the other; access.md says to
turn it from one.
|
| |
|
|
|
|
|
|
|
|
| |
A change is judged as its writer saw the document, and its writer
chooses what it saw. So a capability revoked, a user disabled or a key
removed holds against members that weren't members before it, but a
member that was can still commit, at a history from before, an
envelope the user signed then, and the next, as far as it likes; the
highest `seq` is the place's value. A remake ends it. access.md says
so where it says what signed values keep out.
|
| |
|
|
|
|
|
|
| |
Where the policy asks for signed values, a place's value is chosen by
`seq`, but conflict reports still called the choice `newestWins`, and
the code and the architecture still said "newest" of what a read
shows. A report names it `highestSeq`; the rest says "the one a read
shows".
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A swarm turned strict by writing the policy into it kept the time
before open: a change whose history lacks the policy's change is
judged by the policy then, none or one that isn't strict, needs no
signature there, and is taken whenever it comes, from any member. With
values read by `seq`, an envelope planted at that time with the
highest `seq` there is can never be followed: a ban, a user, a
declaration, for good.
Once a document's policy is strict, a change written under one that
isn't is refused, received or held, unless it is in the history of the
change that wrote the policy the document reads (`store::written_by`).
A node that holds one beside that change, taken before it came, is
told so by any peer that refused it (REFUSALS), judges it again, now
refuses it too, and drops it with what builds on it, as for any change
it took unjudged. A swarm strict from its genesis change has no such
time; one whose policy isn't strict judges as before.
|