Build the swarm

Moves UpdateSharedValidatorsTask to validators.rs. While prior planned to
re-use a validators object across connecting and peer state management, the
current plan is to use an independent validators object for each to minimize
any contention. They should be built infrequently enough, and cheap enough to
update in the majority case (due to quickly checking if an update is needed),
that this is fine.

coordinator/src/p2p/mod.rs

@@ -1,23 +1,36 @@
-use core::future::Future;
 use std::{
   sync::Arc,
   collections::{HashSet, HashMap},
 };
 
-use serai_client::primitives::{NetworkId, PublicKey};
+use zeroize::Zeroizing;
+use schnorrkel::Keypair;
 
-use tokio::sync::RwLock;
+use serai_client::{
+  primitives::{NetworkId, PublicKey},
+  Serai,
+};
 
-use serai_task::ContinuallyRan;
+use tokio::sync::{mpsc, RwLock};
 
-use libp2p::{multihash::Multihash, identity::PeerId, swarm::NetworkBehaviour};
+use serai_task::Task;
+
+use libp2p::{
+  multihash::Multihash,
+  identity::{self, PeerId},
+  tcp::Config as TcpConfig,
+  yamux,
+  swarm::NetworkBehaviour,
+  SwarmBuilder,
+};
 
 /// A struct to sync the validators from the Serai node in order to keep track of them.
 mod validators;
-use validators::{Validators, update_shared_validators};
+use validators::{Validators, UpdateValidatorsTask};
 
 /// The authentication protocol upgrade to limit the P2P network to active validators.
 mod authenticate;
+use authenticate::OnlyValidators;
 
 /// The dial task, to find new peers to connect to
 mod dial;
@@ -34,9 +47,18 @@ mod heartbeat;
 
 /// The swarm task, running it and dispatching to/from it
 mod swarm;
+use swarm::SwarmTask;
 
 const PORT: u16 = 30563; // 5132 ^ (('c' << 8) | 'o')
 
+// usize::max, manually implemented, as max isn't a const fn
+const MAX_LIBP2P_MESSAGE_SIZE: usize =
+  if gossip::MAX_LIBP2P_GOSSIP_MESSAGE_SIZE > reqres::MAX_LIBP2P_REQRES_MESSAGE_SIZE {
+    gossip::MAX_LIBP2P_GOSSIP_MESSAGE_SIZE
+  } else {
+    reqres::MAX_LIBP2P_REQRES_MESSAGE_SIZE
+  };
+
 fn peer_id_from_public(public: PublicKey) -> PeerId {
   // 0 represents the identity Multihash, that no hash was performed
   // It's an internal constant so we can't refer to the constant inside libp2p
@@ -76,19 +98,73 @@ struct Behavior {
   gossip: gossip::Behavior,
 }
 
-struct UpdateSharedValidatorsTask {
-  validators: Arc<RwLock<Validators>>,
-}
+pub(crate) fn new(serai_key: &Zeroizing<Keypair>, serai: Serai) -> P2p {
+  // Define the object we track peers with
+  let peers = Peers { peers: Arc::new(RwLock::new(HashMap::new())) };
 
-impl ContinuallyRan for UpdateSharedValidatorsTask {
-  // Only run every minute, not the default of every five seconds
-  const DELAY_BETWEEN_ITERATIONS: u64 = 60;
-  const MAX_DELAY_BETWEEN_ITERATIONS: u64 = 5 * 60;
+  // Define the dial task
+  let (dial_task_def, dial_task) = Task::new();
+  let (to_dial_send, to_dial_recv) = mpsc::unbounded_channel();
+  todo!("TODO: Dial task");
 
-  fn run_iteration(&mut self) -> impl Send + Future<Output = Result<bool, String>> {
-    async move {
-      update_shared_validators(&self.validators).await.map_err(|e| format!("{e:?}"))?;
-      Ok(true)
-    }
-  }
+  // Define the Validators object used for validating new connections
+  let connection_validators = UpdateValidatorsTask::spawn(serai.clone());
+  let new_only_validators = |noise_keypair: &identity::Keypair| -> Result<_, ()> {
+    Ok(OnlyValidators {
+      serai_key: serai_key.clone(),
+      validators: connection_validators.clone(),
+      noise_keypair: noise_keypair.clone(),
+    })
+  };
+
+  let new_yamux = || {
+    let mut config = yamux::Config::default();
+    // 1 MiB default + max message size
+    config.set_max_buffer_size((1024 * 1024) + MAX_LIBP2P_MESSAGE_SIZE);
+    // 256 KiB default + max message size
+    config.set_receive_window_size(((256 * 1024) + MAX_LIBP2P_MESSAGE_SIZE).try_into().unwrap());
+    config
+  };
+
+  let behavior = Behavior { reqres: reqres::new_behavior(), gossip: gossip::new_behavior() };
+
+  let mut swarm = SwarmBuilder::with_existing_identity(identity::Keypair::generate_ed25519())
+    .with_tokio()
+    .with_tcp(TcpConfig::default().nodelay(false), new_only_validators, new_yamux)
+    .unwrap()
+    .with_behaviour(|_| behavior)
+    .unwrap()
+    .build();
+  swarm.listen_on(format!("/ip4/0.0.0.0/tcp/{PORT}").parse().unwrap()).unwrap();
+  swarm.listen_on(format!("/ip6/::/tcp/{PORT}").parse().unwrap()).unwrap();
+
+  let swarm_validators = UpdateValidatorsTask::spawn(serai);
+
+  let (gossip_send, gossip_recv) = mpsc::unbounded_channel();
+  let (signed_cosigns_send, signed_cosigns_recv) = mpsc::unbounded_channel();
+  let (tributary_gossip_send, tributary_gossip_recv) = mpsc::unbounded_channel();
+
+  let (outbound_requests_send, outbound_requests_recv) = mpsc::unbounded_channel();
+
+  let (heartbeat_requests_send, heartbeat_requests_recv) = mpsc::unbounded_channel();
+  let (notable_cosign_requests_send, notable_cosign_requests_recv) = mpsc::unbounded_channel();
+  let (inbound_request_responses_send, inbound_request_responses_recv) = mpsc::unbounded_channel();
+
+  // Create the swarm task
+  SwarmTask::new(
+    dial_task,
+    to_dial_recv,
+    swarm_validators,
+    peers,
+    swarm,
+    gossip_recv,
+    signed_cosigns_send,
+    tributary_gossip_send,
+    outbound_requests_recv,
+    heartbeat_requests_send,
+    notable_cosign_requests_send,
+    inbound_request_responses_recv,
+  );
+
+  todo!("TODO")
 }