WIP: now retrieving epoch settings from MithrilNetworkConfiguration, adapt inform_epoch_settings signature, TODO fix tests

Author: turmelclem

internal/mithril-protocol-config/src/model.rs

@@ -26,3 +26,20 @@ pub struct MithrilNetworkConfiguration {
     pub signed_entity_types_config:
         HashMap<SignedEntityTypeDiscriminants, SignedEntityTypeConfiguration>,
 }
+
+impl MithrilNetworkConfiguration {
+    /// Get the Cardano Transactions signing configuration
+    pub fn get_cardano_transactions_signing_config(
+        &self,
+    ) -> Option<CardanoTransactionsSigningConfig> {
+        match self
+            .signed_entity_types_config
+            .get(&SignedEntityTypeDiscriminants::CardanoTransactions)
+        {
+            Some(SignedEntityTypeConfiguration::CardanoTransactions(config)) => {
+                Some(config.clone())
+            }
+            _ => None,
+        }
+    }
+}

internal/mithril-protocol-config/src/test/double/dummies.rs

@@ -0,0 +1,35 @@
+use std::collections::{BTreeSet, HashMap};
+
+use mithril_common::{
+    entities::{CardanoTransactionsSigningConfig, SignedEntityTypeDiscriminants},
+    test::double::{Dummy, fake_data},
+};
+
+use crate::model::{MithrilNetworkConfiguration, SignedEntityTypeConfiguration};
+
+impl Dummy for MithrilNetworkConfiguration {
+    /// Return a dummy [MithrilNetworkConfiguration] (test-only).
+    fn dummy() -> Self {
+        let beacon = fake_data::beacon();
+
+        let signer_registration_protocol_parameters = fake_data::protocol_parameters();
+
+        let mut available_signed_entity_types = BTreeSet::new();
+        available_signed_entity_types.insert(SignedEntityTypeDiscriminants::CardanoTransactions);
+
+        let mut signed_entity_types_config = HashMap::new();
+        signed_entity_types_config.insert(
+            SignedEntityTypeDiscriminants::CardanoTransactions,
+            SignedEntityTypeConfiguration::CardanoTransactions(
+                CardanoTransactionsSigningConfig::dummy(),
+            ),
+        );
+
+        Self {
+            epoch: beacon.epoch,
+            signer_registration_protocol_parameters,
+            available_signed_entity_types,
+            signed_entity_types_config,
+        }
+    }
+}

internal/mithril-protocol-config/src/test/double/mod.rs

@@ -1,2 +1,3 @@
+mod dummies;
 mod fake_data;
 pub mod mithril_network_configuration_provider;

mithril-signer/src/runtime/runner.rs

@@ -42,7 +42,12 @@ pub trait Runner: Send + Sync {
     async fn can_sign_current_epoch(&self) -> StdResult<bool>;
 
     /// Register epoch information
-    async fn inform_epoch_settings(&self, epoch_settings: SignerEpochSettings) -> StdResult<()>;
+    async fn inform_epoch_settings(
+        &self,
+        mithril_network_configuration: MithrilNetworkConfiguration,
+        current_signer: Vec<Signer>,
+        next_signer: Vec<Signer>,
+    ) -> StdResult<()>;
 
     /// Create the message to be signed with the single signature.
     async fn compute_message(
@@ -250,25 +255,22 @@ impl Runner for SignerRunner {
         epoch_service.can_signer_sign_current_epoch(self.services.single_signer.get_party_id())
     }
 
-    async fn inform_epoch_settings(&self, epoch_settings: SignerEpochSettings) -> StdResult<()> {
+    async fn inform_epoch_settings(
+        &self,
+        mithril_network_configuration: MithrilNetworkConfiguration,
+        current_signer: Vec<Signer>,
+        next_signer: Vec<Signer>,
+    ) -> StdResult<()> {
         debug!(
             self.logger,
-            ">> inform_epoch_settings(epoch:{})", epoch_settings.epoch
+            ">> inform_epoch_settings(epoch:{})", mithril_network_configuration.epoch
         );
-        let aggregator_features = self
-            .services
-            .certificate_handler
-            .retrieve_aggregator_features()
-            .await?;
 
         self.services
             .epoch_service
             .write()
             .await
-            .inform_epoch_settings(
-                epoch_settings,
-                aggregator_features.capabilities.signed_entity_types,
-            )
+            .inform_epoch_settings(mithril_network_configuration, current_signer, next_signer)
             .await
     }
 
@@ -638,14 +640,20 @@ mod tests {
             .unwrap();
 
         let runner = init_runner(Some(services), None).await;
-        // inform epoch settings
-        let epoch_settings = SignerEpochSettings {
+
+        let mithril_network_configuration = MithrilNetworkConfiguration {
             epoch: current_epoch,
-            current_signers: fixture.signers(),
-            next_signers: fixture.signers(),
-            ..SignerEpochSettings::dummy().clone()
+            ..MithrilNetworkConfiguration::dummy()
         };
-        runner.inform_epoch_settings(epoch_settings).await.unwrap();
+
+        runner
+            .inform_epoch_settings(
+                mithril_network_configuration,
+                fixture.signers(),
+                fixture.signers(),
+            )
+            .await
+            .unwrap();
 
         runner
             .register_signer_to_aggregator()
@@ -697,26 +705,39 @@ mod tests {
     async fn test_inform_epoch_setting_pass_allowed_discriminant_to_epoch_service() {
         let mut services = init_services().await;
         let certificate_handler = Arc::new(DumbAggregatorClient::default());
-        certificate_handler
-            .set_aggregator_features(AggregatorFeaturesMessage {
-                capabilities: AggregatorCapabilities {
-                    signed_entity_types: BTreeSet::from([
-                        SignedEntityTypeDiscriminants::MithrilStakeDistribution,
-                        SignedEntityTypeDiscriminants::CardanoTransactions,
-                    ]),
-                    ..AggregatorFeaturesMessage::dummy().capabilities
-                },
-                ..AggregatorFeaturesMessage::dummy()
-            })
-            .await;
+        // certificate_handler
+        //     .set_aggregator_features(AggregatorFeaturesMessage {
+        //         capabilities: AggregatorCapabilities {
+        //             signed_entity_types: BTreeSet::from([
+        //                 SignedEntityTypeDiscriminants::MithrilStakeDistribution,
+        //                 SignedEntityTypeDiscriminants::CardanoTransactions,
+        //             ]),
+        //             ..AggregatorFeaturesMessage::dummy().capabilities
+        //         },
+        //         ..AggregatorFeaturesMessage::dummy()
+        //     })
+        //     .await;
         services.certificate_handler = certificate_handler;
         let runner = init_runner(Some(services), None).await;
 
-        let epoch_settings = SignerEpochSettings {
+        let mithril_network_configuration = MithrilNetworkConfiguration {
             epoch: Epoch(1),
-            ..SignerEpochSettings::dummy()
+            available_signed_entity_types: BTreeSet::from([
+                SignedEntityTypeDiscriminants::MithrilStakeDistribution,
+                SignedEntityTypeDiscriminants::CardanoTransactions,
+            ]),
+            ..MithrilNetworkConfiguration::dummy()
         };
-        runner.inform_epoch_settings(epoch_settings).await.unwrap();
+
+        // Signers
+        let signers = fake_data::signers(5);
+        let current_signers = signers[1..3].to_vec();
+        let next_signers = signers[2..5].to_vec();
+
+        runner
+            .inform_epoch_settings(mithril_network_configuration, current_signers, next_signers)
+            .await
+            .unwrap();
 
         let epoch_service = runner.services.epoch_service.read().await;
         let recorded_allowed_discriminants = epoch_service.allowed_discriminants().unwrap();

mithril-signer/src/runtime/state_machine.rs

@@ -1,20 +1,17 @@
 use anyhow::Error;
 use chrono::Local;
+use mithril_protocol_config::model::MithrilNetworkConfiguration;
 use slog::{Logger, debug, info};
 use std::{fmt::Display, ops::Deref, sync::Arc, time::Duration};
 use tokio::sync::Mutex;
 
 use mithril_common::{
     crypto_helper::ProtocolInitializerError,
-    entities::{Epoch, TimePoint},
+    entities::{Epoch, Signer, TimePoint},
     logging::LoggerExtensions,
 };
 
-use crate::{
-    MetricsService,
-    entities::{BeaconToSign, SignerEpochSettings},
-    services::AggregatorClientError,
-};
+use crate::{MetricsService, entities::BeaconToSign, services::AggregatorClientError};
 
 use super::{Runner, RuntimeError};
 
@@ -167,7 +164,7 @@ impl StateMachine {
                         "→ Epoch has changed, transiting to Unregistered"
                     );
                     *state = self.transition_from_unregistered_to_unregistered(new_epoch).await?;
-                } else if let Some(epoch_settings) = self
+                } else if let Some(signer_settings) = self
                     .runner
                     .get_epoch_settings()
                     .await
@@ -176,19 +173,33 @@ impl StateMachine {
                         nested_error: Some(e),
                     })?
                 {
-                    info!(self.logger, "→ Epoch settings found");
-                    if epoch_settings.epoch >= *epoch {
+                    info!(self.logger, "→ Epoch settings found"); //TODO Do we switch the logs and type from SignerEpochSettings to SignerSettings since now we only read current and next signer from it ?
+                    let network_configuration = self
+                        .runner
+                        .get_mithril_network_configuration()
+                        .await
+                        .map_err(|e| RuntimeError::KeepState {
+                            message: "could not retrieve mithril network configuration".to_string(),
+                            nested_error: Some(e),
+                        })?;
+                    info!(self.logger, "→ Mithril network configuration found");
+
+                    if network_configuration.epoch >= *epoch {
                         info!(self.logger, "New Epoch found");
                         info!(self.logger, " ⋅ Transiting to Registered");
                         *state = self
                             .transition_from_unregistered_to_one_of_registered_states(
-                                epoch_settings,
+                                network_configuration,
+                                signer_settings.current_signers,
+                                signer_settings.next_signers,
                             )
                             .await?;
                     } else {
                         info!(
-                            self.logger, " ⋅ Epoch settings found, but its epoch is behind the known epoch, waiting…";
-                            "epoch_settings" => ?epoch_settings,
+                            self.logger, " ⋅ Signer settings and Network Configuration found, but its epoch is behind the known epoch, waiting…";
+                            "network_configuration" => ?network_configuration,
+                            "current_singer" => ?signer_settings.current_signers,
+                            "next_signer" => ?signer_settings.next_signers,
                             "known_epoch" => ?epoch,
                         );
                     }
@@ -286,7 +297,9 @@ impl StateMachine {
     /// Launch the transition process from the `Unregistered` to `ReadyToSign` or `RegisteredNotAbleToSign` state.
     async fn transition_from_unregistered_to_one_of_registered_states(
         &self,
-        epoch_settings: SignerEpochSettings,
+        mithril_network_configuration: MithrilNetworkConfiguration,
+        current_signer: Vec<Signer>,
+        next_signer: Vec<Signer>,
     ) -> Result<SignerState, RuntimeError> {
         self.metrics_service
             .get_signer_registration_total_since_startup_counter()
@@ -302,7 +315,7 @@ impl StateMachine {
             })?;
 
         self.runner
-            .inform_epoch_settings(epoch_settings)
+            .inform_epoch_settings(mithril_network_configuration, current_signer,  next_signer)
             .await
             .map_err(|e| RuntimeError::KeepState {
                 message: format!(
@@ -474,11 +487,13 @@ impl StateMachine {
 mod tests {
     use anyhow::anyhow;
     use chrono::DateTime;
+    use mithril_protocol_config::model::MithrilNetworkConfiguration;
     use mockall::predicate;
 
     use mithril_common::entities::{ChainPoint, Epoch, ProtocolMessage, SignedEntityType};
     use mithril_common::test::double::{Dummy, fake_data};
 
+    use crate::SignerEpochSettings;
     use crate::runtime::runner::MockSignerRunner;
     use crate::services::AggregatorClientError;
     use crate::test_tools::TestLogger;
@@ -528,7 +543,7 @@ mod tests {
     async fn unregistered_epoch_settings_behind_known_epoch() {
         let mut runner = MockSignerRunner::new();
         let epoch_settings = SignerEpochSettings {
-            epoch: Epoch(3),
+            epoch: Epoch(999), // epoch is no longer read from get_epoch_settings anymore but from mithril network configuration
             registration_protocol_parameters: fake_data::protocol_parameters(),
             current_signers: vec![],
             next_signers: vec![],
@@ -539,6 +554,17 @@ mod tests {
             .expect_get_epoch_settings()
             .once()
             .returning(move || Ok(Some(epoch_settings.to_owned())));
+        runner
+            .expect_get_mithril_network_configuration()
+            .once()
+            .returning(|| {
+                Ok(MithrilNetworkConfiguration {
+                    epoch: Epoch(3),
+                    signer_registration_protocol_parameters: fake_data::protocol_parameters(),
+                    available_signed_entity_types: Default::default(),
+                    signed_entity_types_config: Default::default(),
+                })
+            });
         runner.expect_get_current_time_point().once().returning(|| {
             Ok(TimePoint {
                 epoch: Epoch(4),
@@ -567,11 +593,21 @@ mod tests {
             .once()
             .returning(|| Ok(Some(SignerEpochSettings::dummy())));
 
+        runner
+            .expect_get_mithril_network_configuration()
+            .once()
+            .returning(|| Ok(MithrilNetworkConfiguration::dummy()));
+
         runner
             .expect_inform_epoch_settings()
-            .with(predicate::eq(SignerEpochSettings::dummy()))
+            .with(
+                //todo do we really want to specify a WITH ?
+                predicate::eq(MithrilNetworkConfiguration::dummy()),
+                predicate::eq(SignerEpochSettings::dummy().current_signers),
+                predicate::eq(SignerEpochSettings::dummy().next_signers),
+            )
             .once()
-            .returning(|_| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         runner
             .expect_get_current_time_point()
@@ -615,11 +651,21 @@ mod tests {
             .once()
             .returning(|| Ok(Some(SignerEpochSettings::dummy())));
 
+        runner
+            .expect_get_mithril_network_configuration()
+            .once()
+            .returning(|| Ok(MithrilNetworkConfiguration::dummy()));
+
         runner
             .expect_inform_epoch_settings()
-            .with(predicate::eq(SignerEpochSettings::dummy()))
+            .with(
+                //todo do we really want to specify a WITH ?
+                predicate::eq(MithrilNetworkConfiguration::dummy()),
+                predicate::eq(SignerEpochSettings::dummy().current_signers),
+                predicate::eq(SignerEpochSettings::dummy().next_signers),
+            )
             .once()
-            .returning(|_| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         runner
             .expect_get_current_time_point()
@@ -667,11 +713,21 @@ mod tests {
             .once()
             .returning(|| Ok(Some(SignerEpochSettings::dummy())));
 
+        runner
+            .expect_get_mithril_network_configuration()
+            .once()
+            .returning(|| Ok(MithrilNetworkConfiguration::dummy()));
+
         runner
             .expect_inform_epoch_settings()
-            .with(predicate::eq(SignerEpochSettings::dummy()))
+            .with(
+                //todo do we really want to specify a WITH ?
+                predicate::eq(MithrilNetworkConfiguration::dummy()),
+                predicate::eq(SignerEpochSettings::dummy().current_signers),
+                predicate::eq(SignerEpochSettings::dummy().next_signers),
+            )
             .once()
-            .returning(|_| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         runner
             .expect_get_current_time_point()