roots: an epoch's root pinned, and named in every handshake

Review 2, N7, the care it raised: a joining node's empty document took
as the first epoch's root whatever dependency-less change came first,
from whichever peer it joined through; the first epoch's ID is all
zeros, so nothing pinned it. A remake's epoch has its ID, the snapshot
change's hash, which the rules hold its root to.

* Every node names its epoch's root in HELLO and HELLO_REPLY (the
  epoch's ID for a remake's, its genesis change for the first; wire
  version 45). A node whose document starts from another root of the
  same epoch refuses the handshake, logging it: another history under
  the swarm's ID, a forged root or a genesis started again.
* A joining node with an empty document takes as its root only the one
  it was given (--genesis-root, new), else the one its peers name, and
  none while they name different ones (access::screen::RootPin, kept
  in Screening across documents): one peer hands it another root only
  if it is all the joiner hears, or never, with --genesis-root. A root
  refused is listed with the refused, what builds on it with it.
* The genesis node logs the root (`The swarm's root`); GET
  /admin/epochs shows it (`root`).

A genesis started again under a remembered swarm ID used to merge with
the nodes of it still running; they now refuse it (another root), and
the docs say to join them with seeds instead.

The epoch's identity stays as it is (generation 0 all zeros): records
and epoch metadata name it so, and every comparison of epochs with
them.

2 files changed, 18 insertions, 0 deletions

diff --git a/src/swarm/peer/handshake.rs b/src/swarm/peer/handshake.rs
index b964064..8e9b0ef 100644
--- a/src/swarm/peer/handshake.rs
+++ b/src/swarm/peer/handshake.rs
@@ -139,6 +139,9 @@ async fn transmit_hello(state: &AppState, peer: &str) -> Result<()> {
                 ready: state.is_ready().await,
                 run_id: state.run_id,
                 handshake,
+                root: crate::swarm::roots::own(state)
+                    .await
+                    .map(|root| root.0.to_vec()),
             }),
         )
         .await;
@@ -236,6 +239,9 @@ pub(super) async fn send_hello_reply(
         run_id,
         away_ms: away.map(|away| away.as_millis() as u64),
         sender_run_id: state.run_id,
+        root: crate::swarm::roots::own(state)
+            .await
+            .map(|root| root.0.to_vec()),
     };
 
     debug!(to = %peer, ready, "Sending HELLO_REPLY");
diff --git a/src/swarm/peer/inbound.rs b/src/swarm/peer/inbound.rs
index a7633b3..3ddaf08 100644
--- a/src/swarm/peer/inbound.rs
+++ b/src/swarm/peer/inbound.rs
@@ -96,6 +96,18 @@ pub(crate) async fn handle_message(
         return Ok(());
     }
 
+    // The root its document starts from: another than ours, of our epoch, is another
+    // history; what a joiner takes as its root follows those named (`swarm::roots`).
+    match &message {
+        ParsedMessage::Hello(hello) => {
+            crate::swarm::roots::heard(state, &peer, epoch, hello.root.as_deref()).await?
+        }
+        ParsedMessage::HelloReply(reply) => {
+            crate::swarm::roots::heard(state, &peer, epoch, reply.root.as_deref()).await?
+        }
+        _ => {}
+    }
+
     remember_peer(state, &peer).await;
 
     let run = match &message {