feat(aggregator): implement local configuration for mithril network configuration and adapt epoch service

Author: turmelclem

mithril-aggregator/src/dependency_injection/builder/enablers/epoch.rs

@@ -1,24 +1,30 @@
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
+use mithril_protocol_config::{
+    http::HttpMithrilNetworkConfigurationProvider, interface::MithrilNetworkConfigurationProvider,
+};
+
 use crate::dependency_injection::{DependenciesBuilder, EpochServiceWrapper, Result};
 use crate::get_dependency;
-use crate::services::{EpochServiceDependencies, MithrilEpochService};
+use crate::services::{
+    EpochServiceDependencies, LocalMithrilNetworkConfigurationProvider, MithrilEpochService,
+};
+
 impl DependenciesBuilder {
     async fn build_epoch_service(&mut self) -> Result<EpochServiceWrapper> {
         let verification_key_store = self.get_verification_key_store().await?;
         let epoch_settings_storer = self.get_epoch_settings_store().await?;
         let chain_observer = self.get_chain_observer().await?;
         let era_checker = self.get_era_checker().await?;
         let stake_store = self.get_stake_store().await?;
-        let epoch_settings = self.configuration.get_epoch_settings_configuration();
         let allowed_discriminants = self
             .configuration
             .compute_allowed_signed_entity_types_discriminants()?;
 
         let epoch_service = Arc::new(RwLock::new(MithrilEpochService::new(
-            epoch_settings,
             EpochServiceDependencies::new(
+                self.get_mithril_network_configuration_provider().await?,
                 epoch_settings_storer,
                 verification_key_store,
                 chain_observer,
@@ -36,4 +42,33 @@ impl DependenciesBuilder {
     pub async fn get_epoch_service(&mut self) -> Result<EpochServiceWrapper> {
         get_dependency!(self.epoch_service)
     }
+
+    async fn build_mithril_network_configuration_provider(
+        &mut self,
+    ) -> Result<Arc<dyn MithrilNetworkConfigurationProvider>> {
+        let network_configuration_provider: Arc<dyn MithrilNetworkConfigurationProvider> =
+            if self.configuration.is_follower_aggregator() {
+                Arc::new(HttpMithrilNetworkConfigurationProvider::new(
+                    self.get_leader_aggregator_client().await?,
+                ))
+            } else {
+                Arc::new(LocalMithrilNetworkConfigurationProvider::new(
+                    self.configuration.get_epoch_settings_configuration(),
+                    self.configuration
+                        .compute_allowed_signed_entity_types_discriminants()?,
+                    self.get_epoch_settings_store().await?,
+                ))
+            };
+
+        //TODO handle discrepency here
+
+        Ok(network_configuration_provider)
+    }
+
+    /// [MithrilNetworkConfigurationProvider][mithril_protocol_config::interface::MithrilNetworkConfigurationProvider] service
+    pub async fn get_mithril_network_configuration_provider(
+        &mut self,
+    ) -> Result<Arc<dyn MithrilNetworkConfigurationProvider>> {
+        get_dependency!(self.mithril_network_configuration_provider)
+    }
 }

mithril-aggregator/src/dependency_injection/builder/enablers/mithril_network_configuration.rs

@@ -3,5 +3,4 @@
 mod cardano_node;
 mod epoch;
 mod misc;
-mod mithril_network_configuration;
 mod ticker;

mithril-aggregator/src/dependency_injection/builder/enablers/mod.rs

@@ -36,6 +36,7 @@ use mithril_persistence::{
     database::repository::CardanoTransactionRepository,
     sqlite::{SqliteConnection, SqliteConnectionPool},
 };
+use mithril_protocol_config::interface::MithrilNetworkConfigurationProvider;
 use mithril_signed_entity_lock::SignedEntityTypeLock;
 use mithril_ticker::TickerService;
 
@@ -254,6 +255,10 @@ pub struct DependenciesBuilder {
     /// Epoch service.
     pub epoch_service: Option<EpochServiceWrapper>,
 
+    /// Mithril network configuration provider
+    pub mithril_network_configuration_provider:
+        Option<Arc<dyn MithrilNetworkConfigurationProvider>>,
+
     /// Signed Entity storer
     pub signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>,
 
@@ -339,6 +344,7 @@ impl DependenciesBuilder {
             signed_entity_service: None,
             certifier_service: None,
             epoch_service: None,
+            mithril_network_configuration_provider: None,
             signed_entity_storer: None,
             message_service: None,
             prover_service: None,
@@ -395,6 +401,9 @@ impl DependenciesBuilder {
             signed_entity_service: self.get_signed_entity_service().await?,
             certifier_service: self.get_certifier_service().await?,
             epoch_service: self.get_epoch_service().await?,
+            mithril_network_configuration_provider: self
+                .get_mithril_network_configuration_provider()
+                .await?,
             ticker_service: self.get_ticker_service().await?,
             signed_entity_storer: self.get_signed_entity_storer().await?,
             signer_getter: self.get_signer_store().await?,

mithril-aggregator/src/dependency_injection/builder/mod.rs

@@ -1,3 +1,4 @@
+use mithril_protocol_config::interface::MithrilNetworkConfigurationProvider;
 use slog::Logger;
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -100,6 +101,9 @@ pub struct ServeCommandDependenciesContainer {
     /// Epoch service
     pub(crate) epoch_service: EpochServiceWrapper,
 
+    /// Mithril network configuration provider
+    pub(crate) mithril_network_configuration_provider: Arc<dyn MithrilNetworkConfigurationProvider>,
+
     /// Ticker Service
     pub(crate) ticker_service: Arc<dyn TickerService>,
 

mithril-aggregator/src/dependency_injection/containers/serve.rs

@@ -9,3 +9,31 @@ pub struct AggregatorEpochSettings {
     /// Cardano transactions signing configuration
     pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
 }
+
+#[cfg(test)]
+mod test_utils {
+    use std::collections::BTreeSet;
+
+    use mithril_common::entities::SignedEntityTypeDiscriminants;
+    use mithril_protocol_config::model::{
+        MithrilNetworkConfigurationForEpoch, SignedEntityTypeConfiguration,
+    };
+
+    use super::*;
+
+    impl AggregatorEpochSettings {
+        /// Convert this epoch setting into a [MithrilNetworkConfigurationForEpoch]
+        pub fn into_network_configuration_for_epoch(
+            self,
+            enabled_signed_entity_types: BTreeSet<SignedEntityTypeDiscriminants>,
+        ) -> MithrilNetworkConfigurationForEpoch {
+            MithrilNetworkConfigurationForEpoch {
+                protocol_parameters: self.protocol_parameters,
+                enabled_signed_entity_types,
+                signed_entity_types_config: SignedEntityTypeConfiguration {
+                    cardano_transactions: Some(self.cardano_transactions_signing_config),
+                },
+            }
+        }
+    }
+}