Check validator key in network crate

node/actors/executor/src/lib.rs

@@ -198,7 +198,8 @@ impl<S: WriteBlockStore + 'static> Executor<S> {
         scope::run!(ctx, |ctx, s| async {
             s.spawn_blocking(|| dispatcher.run(ctx).context("IO Dispatcher stopped"));
             s.spawn(async {
-                let state = network::State::new(network_config, None, Some(sync_blocks_subscriber));
+                let state = network::State::new(network_config, None, Some(sync_blocks_subscriber))
+                    .context("Invalid network config")?;
                 state.register_metrics();
                 network::run_network(ctx, state, network_actor_pipe)
                     .await

node/actors/network/src/consensus/state.rs

@@ -26,12 +26,20 @@ pub(crate) struct State {
 
 impl State {
     /// Constructs a new State.
-    pub(crate) fn new(cfg: Config, validators: &ValidatorSet) -> Self {
+    pub(crate) fn new(cfg: Config, validators: &ValidatorSet) -> anyhow::Result<Self> {
         let validators: HashSet<_> = validators.iter().cloned().collect();
-        Self {
+        let current_validator_key = cfg.key.public();
+        anyhow::ensure!(
+            validators.contains(&current_validator_key),
+            "Validators' public keys {validators:?} do not contain the current validator \
+             {current_validator_key:?}; this is not yet supported"
+        );
+        // ^ This check will be relaxed once we support dynamic validator membership
+
+        Ok(Self {
             cfg,
             inbound: PoolWatch::new(validators.clone(), 0),
             outbound: PoolWatch::new(validators, 0),
-        }
+        })
     }
 }

node/actors/network/src/state.rs

@@ -54,18 +54,21 @@ impl State {
         cfg: Config,
         events: Option<channel::UnboundedSender<Event>>,
         sync_state: Option<watch::Receiver<SyncState>>,
-    ) -> Arc<Self> {
-        Arc::new(Self {
+    ) -> anyhow::Result<Arc<Self>> {
+        let consensus = cfg
+            .consensus
+            .map(|consensus_cfg| consensus::State::new(consensus_cfg, &cfg.validators))
+            .transpose()?;
+        let this = Self {
             gossip: gossip::State::new(cfg.gossip, sync_state),
-            consensus: cfg
-                .consensus
-                .map(|consensus_cfg| consensus::State::new(consensus_cfg, &cfg.validators)),
+            consensus,
             events,
             cfg: SharedConfig {
                 server_addr: cfg.server_addr,
                 validators: cfg.validators,
             },
-        })
+        };
+        Ok(Arc::new(this))
     }
 
     /// Registers metrics for this state.

node/actors/network/src/testonly.rs

@@ -88,7 +88,7 @@ impl Instance {
     pub(crate) fn from_cfg(cfg: Config) -> Self {
         let (events_send, events_recv) = channel::unbounded();
         Self {
-            state: State::new(cfg, Some(events_send), None),
+            state: State::new(cfg, Some(events_send), None).expect("Invalid network config"),
             events: events_recv,
         }
     }