feat(common): make cardano transactions signing config optional in SignedEntityConfig

This make the network resilient to a removal of this configuration at
the expense of moving the error handling to nodes 'beacon to sign'
computations (done in their state machines).

Notes: leader aggregator will fails directly at startup if an incoherent
configuration, which enable cardano transactions but don't specifies the
associated configuration, is provided.

Author: Alenar

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

@@ -66,11 +66,6 @@ impl MithrilNetworkConfigurationProvider for HttpMithrilNetworkConfigurationProv
             ))?
             .into();
 
-        configuration_for_aggregation.signed_entity_types_config.cardano_transactions.clone()
-            .ok_or_else(|| {
-                anyhow!(format!("Cardano transactions signing config is missing in aggregation configuration for epoch {epoch}"))
-            })?;
-
         Ok(MithrilNetworkConfiguration {
             epoch,
             configuration_for_aggregation,

mithril-aggregator/src/services/epoch_service.rs

@@ -348,10 +348,7 @@ impl EpochService for MithrilEpochService {
                 .configuration_for_aggregation
                 .signed_entity_types_config
                 .cardano_transactions
-                .clone()
-                .ok_or(anyhow!(
-                    "Missing cardano transactions signing config for current epoch {epoch:?}"
-                ))?,
+                .clone(),
         };
 
         let (total_spo, total_stake) =
@@ -1073,10 +1070,10 @@ mod tests {
     async fn inform_epoch_get_signed_entity_config_from_its_dependencies_and_store() {
         let epoch = Epoch(5);
 
-        let cardano_transactions_signing_config = CardanoTransactionsSigningConfig {
+        let cardano_transactions_signing_config = Some(CardanoTransactionsSigningConfig {
             security_parameter: BlockNumber(29),
             step: BlockNumber(986),
-        };
+        });
         let allowed_discriminants = BTreeSet::from([
             SignedEntityTypeDiscriminants::CardanoTransactions,
             SignedEntityTypeDiscriminants::CardanoImmutableFilesFull,
@@ -1085,9 +1082,7 @@ mod tests {
         let mut service = EpochServiceBuilder {
             allowed_discriminants: allowed_discriminants.clone(),
             stored_current_epoch_settings: AggregatorEpochSettings {
-                cardano_transactions_signing_config: Some(
-                    cardano_transactions_signing_config.clone(),
-                ),
+                cardano_transactions_signing_config: cardano_transactions_signing_config.clone(),
                 ..AggregatorEpochSettings::dummy()
             },
             ..EpochServiceBuilder::new(epoch, MithrilFixtureBuilder::default().build())

mithril-aggregator/src/services/message.rs

@@ -190,7 +190,7 @@ impl MessageService for MithrilMessageService {
             current_signers: SignerMessagePart::from_signers(current_signers.to_vec()),
             next_signers: SignerMessagePart::from_signers(next_signers.to_vec()),
             cardano_transactions_signing_config: signed_entity_config
-                .map(|c| c.cardano_transactions_signing_config),
+                .and_then(|c| c.cardano_transactions_signing_config),
         };
 
         Ok(epoch_settings_message)
@@ -635,7 +635,7 @@ mod tests {
             };
             let epoch_service = FakeEpochServiceBuilder {
                 signed_entity_config: SignedEntityConfig {
-                    cardano_transactions_signing_config: expected_ctx_config.clone(),
+                    cardano_transactions_signing_config: Some(expected_ctx_config.clone()),
                     ..Dummy::dummy()
                 },
                 ..FakeEpochServiceBuilder::dummy(Epoch(1))

mithril-common/src/entities/signed_entity_config.rs

@@ -15,7 +15,7 @@ pub struct SignedEntityConfig {
     /// List of discriminants that the node is allowed to sign
     pub allowed_discriminants: BTreeSet<SignedEntityTypeDiscriminants>,
     /// Cardano transactions signing configuration
-    pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
 
 impl SignedEntityConfig {
@@ -66,11 +66,18 @@ impl SignedEntityConfig {
                 ))
             }
             SignedEntityTypeDiscriminants::CardanoTransactions => {
-                SignedEntityType::CardanoTransactions(
-                    time_point.epoch,
-                    self.cardano_transactions_signing_config
-                        .compute_block_number_to_be_signed(time_point.chain_point.block_number),
-                )
+                match &self.cardano_transactions_signing_config {
+                    Some(config) => SignedEntityType::CardanoTransactions(
+                        time_point.epoch,
+                        config
+                            .compute_block_number_to_be_signed(time_point.chain_point.block_number),
+                    ),
+                    None => {
+                        anyhow::bail!(
+                            "Can't derive a CardanoTransactions signed entity type from a time point without a `CardanoTransactionsSigningConfig`"
+                        )
+                    }
+                }
             }
             SignedEntityTypeDiscriminants::CardanoDatabase => SignedEntityType::CardanoDatabase(
                 CardanoDbBeacon::new(*time_point.epoch, time_point.immutable_file_number),
@@ -163,10 +170,10 @@ mod tests {
         };
         let config = SignedEntityConfig {
             allowed_discriminants: SignedEntityTypeDiscriminants::all(),
-            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+            cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(0),
                 step: BlockNumber(15),
-            },
+            }),
         };
 
         assert_eq!(
@@ -224,6 +231,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn can_not_convert_time_point_to_cardano_transaction_without_the_associated_config() {
+        let time_point = TimePoint {
+            epoch: Epoch(1),
+            immutable_file_number: 5,
+            chain_point: ChainPoint {
+                slot_number: SlotNumber(73),
+                block_number: BlockNumber(20),
+                block_hash: "block_hash-20".to_string(),
+            },
+        };
+        let config = SignedEntityConfig {
+            allowed_discriminants: SignedEntityTypeDiscriminants::all(),
+            cardano_transactions_signing_config: None,
+        };
+
+        let error = config
+            .time_point_to_signed_entity(
+                SignedEntityTypeDiscriminants::CardanoTransactions,
+                &time_point,
+            )
+            .unwrap_err();
+
+        let expected_error = "Can't derive a CardanoTransactions signed entity type from a time point without a `CardanoTransactionsSigningConfig`";
+        assert!(
+            error.to_string().contains(expected_error),
+            "Error message: {error:?}\nshould contains: {expected_error}\n"
+        );
+    }
+
     #[test]
     fn computing_block_number_to_be_signed() {
         // **block_number = ((tip.block_number - k') / n) × n**
@@ -422,10 +459,10 @@ mod tests {
                 SignedEntityTypeDiscriminants::CardanoStakeDistribution,
                 SignedEntityTypeDiscriminants::CardanoTransactions,
             ]),
-            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+            cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(0),
                 step: BlockNumber(15),
-            },
+            }),
         };
 
         let signed_entity_types = config.list_allowed_signed_entity_types(&time_point).unwrap();

mithril-common/src/test/double/dummies.rs

@@ -41,7 +41,7 @@ mod entities {
         fn dummy() -> Self {
             Self {
                 allowed_discriminants: SignedEntityTypeDiscriminants::all(),
-                cardano_transactions_signing_config: CardanoTransactionsSigningConfig::dummy(),
+                cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig::dummy()),
             }
         }
     }

mithril-signer/src/services/certifier.rs

@@ -525,7 +525,7 @@ mod tests {
             ) -> Self {
                 Self {
                     config: SignedEntityConfig {
-                        cardano_transactions_signing_config: config,
+                        cardano_transactions_signing_config: Some(config),
                         allowed_discriminants,
                     },
                 }

mithril-signer/src/services/epoch_service.rs

@@ -1,4 +1,3 @@
-use anyhow::anyhow;
 use async_trait::async_trait;
 use mithril_protocol_config::model::MithrilNetworkConfiguration;
 use slog::{Logger, debug, trace, warn};
@@ -308,15 +307,12 @@ impl SignerSignedEntityConfigProvider {
 impl SignedEntityConfigProvider for SignerSignedEntityConfigProvider {
     async fn get(&self) -> StdResult<SignedEntityConfig> {
         let epoch_service = self.epoch_service.read().await;
-        let cardano_transactions_signing_config =
-            match epoch_service.cardano_transactions_signing_config()? {
-                Some(config) => Ok(config.clone()),
-                None => Err(anyhow!("No cardano transaction signing config available")),
-            }?;
 
         Ok(SignedEntityConfig {
             allowed_discriminants: epoch_service.allowed_discriminants()?.clone(),
-            cardano_transactions_signing_config,
+            cardano_transactions_signing_config: epoch_service
+                .cardano_transactions_signing_config()?
+                .clone(),
         })
     }
 }
@@ -905,17 +901,19 @@ mod tests {
                 "Should fail since sources data are not set before the first inform_epoch_settings",
             );
         }
-        // Fail after `inform_epoch_settings` if `cardano_transactions_signing_config` is not set
+        // Success after `inform_epoch_settings` even if `cardano_transactions_signing_config` is not set
         {
             let signers = fake_data::signers(5);
             let current_signers = signers[1..3].to_vec();
             let next_signers = signers[2..5].to_vec();
+            let allowed_discriminants =
+                BTreeSet::from([SignedEntityTypeDiscriminants::CardanoStakeDistribution]);
 
             let configuration_for_aggregation = MithrilNetworkConfigurationForEpoch {
                 signed_entity_types_config: SignedEntityTypeConfiguration {
                     cardano_transactions: None,
                 },
-                enabled_signed_entity_types: BTreeSet::new(),
+                enabled_signed_entity_types: allowed_discriminants.clone(),
                 ..Dummy::dummy()
             };
             let configuration_for_next_aggregation = MithrilNetworkConfigurationForEpoch::dummy();
@@ -936,10 +934,15 @@ mod tests {
                 .await
                 .unwrap();
 
-            config_provider
-                .get()
-                .await
-                .expect_err("Should fail since cardano_transactions_signing_config is not set");
+            let config = config_provider.get().await.unwrap();
+
+            assert_eq!(
+                SignedEntityConfig {
+                    allowed_discriminants,
+                    cardano_transactions_signing_config: None,
+                },
+                config
+            );
         }
         // Success after `inform_epoch_settings` if `cardano_transactions_signing_config` is set
         {
@@ -975,7 +978,9 @@ mod tests {
             assert_eq!(
                 SignedEntityConfig {
                     allowed_discriminants,
-                    cardano_transactions_signing_config: CardanoTransactionsSigningConfig::dummy(),
+                    cardano_transactions_signing_config: Some(
+                        CardanoTransactionsSigningConfig::dummy()
+                    ),
                 },
                 config
             );