Feature/rust rewarding

validator-api/src/network_monitor/monitor/preparer.rs

@@ -13,6 +13,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::forwarding::packet::MixPacket;
 use std::convert::TryInto;
 use std::fmt::{self, Display, Formatter};
+use std::time::Duration;
 use topology::{gateway, mix};
 
 // declared type aliases for easier code reasoning
@@ -167,10 +168,31 @@ impl PacketPreparer {
     }
 
     pub(crate) async fn wait_for_validator_cache_initial_values(&self) {
+        // wait for the cache to get initialised
         self.validator_cache.wait_for_initial_values().await;
+
+        // now wait for our "good" topology to be online
+        info!("Waiting for 'good' topology to be online");
+        let initialisation_backoff = Duration::from_secs(30);
+        loop {
+            let gateways = self.validator_cache.gateways().await;
+            let mixnodes = self.validator_cache.mixnodes().await;
+            if self
+                .tested_network
+                .is_online(&mixnodes.into_inner(), &gateways.into_inner())
+            {
+                break;
+            } else {
+                info!(
+                    "Our 'good' topology is still not offline. Going to check again in {:?}",
+                    initialisation_backoff
+                );
+                tokio::time::sleep(initialisation_backoff).await;
+            }
+        }
     }
 
-    async fn get_network_nodes(&mut self) -> (Vec<MixNodeBond>, Vec<GatewayBond>) {
+    async fn get_network_nodes(&self) -> (Vec<MixNodeBond>, Vec<GatewayBond>) {
         info!(target: "Monitor", "Obtaining network topology...");
 
         let mixnodes = self.validator_cache.mixnodes().await.into_inner();

validator-api/src/network_monitor/tested_network/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::network_monitor::test_packet::IpVersion;
+use mixnet_contract::{GatewayBond, MixNodeBond};
 use topology::{gateway, mix, NymTopology};
 
 pub(crate) mod good_topology;
@@ -68,4 +69,40 @@ impl TestedNetwork {
     pub(crate) fn v6_topology(&self) -> &NymTopology {
         &self.good_v6_topology
     }
+
+    /// Given slices of bonded mixnodes and gateways, checks whether all 'good' nodes are present
+    /// in the lists.
+    ///
+    /// # Arguments
+    ///
+    /// * `bonded_mixnodes`: slice of currently bonded mixnodes
+    /// * `bonded_gateways`: slice of currently bonded gateways
+    pub(crate) fn is_online(
+        &self,
+        bonded_mixnodes: &[MixNodeBond],
+        bonded_gateways: &[GatewayBond],
+    ) -> bool {
+        // while technically this is not the most optimal way of checking all nodes as we have to
+        // go through entire slice multiple times, we only do it every 30s before monitor startup
+        // so it's not really that bad
+        for layer_mixes in self.good_v4_topology.mixes().values() {
+            for mix in layer_mixes {
+                if !bonded_mixnodes.iter().any(|bonded| {
+                    bonded.mix_node.identity_key == mix.identity_key.to_base58_string()
+                }) {
+                    return false;
+                }
+            }
+        }
+
+        for gateway in self.good_v4_topology.gateways() {
+            if !bonded_gateways.iter().any(|bonded| {
+                bonded.gateway.identity_key == gateway.identity_key.to_base58_string()
+            }) {
+                return false;
+            }
+        }
+
+        true
+    }
 }