refactor: support optional cardano transaction signing config

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/configuration.rs

@@ -382,15 +382,25 @@ pub trait ConfigurationSource {
     fn get_leader_aggregator_epoch_settings_configuration(
         &self,
     ) -> StdResult<AggregatorEpochSettings> {
+        let allowed_discriminants = self.compute_allowed_signed_entity_types_discriminants()?;
+
+        let cardano_transactions_signing_config = if allowed_discriminants
+            .contains(&SignedEntityTypeDiscriminants::CardanoTransactions)
+        {
+            let cardano_transactions_signing_config =
+                self.cardano_transactions_signing_config().with_context(
+                    || "Configuration `cardano_transactions_signing_config` is mandatory for a Leader Aggregator when `CardanoTransactions` is enabled in `signed_entity_types`"
+                )?;
+            Some(cardano_transactions_signing_config)
+        } else {
+            None
+        };
+
         Ok(AggregatorEpochSettings {
             protocol_parameters: self.protocol_parameters().with_context(
                 || "Configuration `protocol_parameters` is mandatory for a Leader Aggregator",
             )?,
-            cardano_transactions_signing_config: self
-                .cardano_transactions_signing_config()
-                .with_context(
-                || "Configuration `cardano_transactions_signing_config` is mandatory for a Leader Aggregator",
-                )?,
+            cardano_transactions_signing_config,
         })
     }
 
@@ -1152,6 +1162,7 @@ impl Source for DefaultConfiguration {
 #[cfg(test)]
 mod test {
     use mithril_common::temp_dir;
+    use mithril_common::test::double::fake_data;
 
     use super::*;
 
@@ -1315,6 +1326,80 @@ mod test {
         assert!(!config.is_follower_aggregator());
     }
 
+    mod get_leader_aggregator_epoch_settings_configuration {
+        use super::*;
+
+        #[test]
+        fn succeed_when_cardano_transactions_is_disabled_and_cardano_transactions_signing_config_is_not_set()
+         {
+            let epoch_settings = ServeCommandConfiguration {
+                signed_entity_types: None,
+                cardano_transactions_signing_config: None,
+                protocol_parameters: Some(ProtocolParameters::new(1, 2, 3.1)),
+                ..ServeCommandConfiguration::new_sample(temp_dir!())
+            }
+            .get_leader_aggregator_epoch_settings_configuration()
+            .unwrap();
+
+            assert_eq!(
+                AggregatorEpochSettings {
+                    protocol_parameters: ProtocolParameters::new(1, 2, 3.1),
+                    cardano_transactions_signing_config: None
+                },
+                epoch_settings
+            );
+        }
+
+        #[test]
+        fn succeed_when_cardano_transactions_is_enabled_and_cardano_transactions_signing_config_is_set()
+         {
+            let epoch_settings = ServeCommandConfiguration {
+                signed_entity_types: Some(
+                    SignedEntityTypeDiscriminants::CardanoTransactions.to_string(),
+                ),
+                cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
+                    security_parameter: BlockNumber(10),
+                    step: BlockNumber(30),
+                }),
+                protocol_parameters: Some(ProtocolParameters::new(2, 3, 4.1)),
+                ..ServeCommandConfiguration::new_sample(temp_dir!())
+            }
+            .get_leader_aggregator_epoch_settings_configuration()
+            .unwrap();
+
+            assert_eq!(
+                AggregatorEpochSettings {
+                    protocol_parameters: ProtocolParameters::new(2, 3, 4.1),
+                    cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
+                        security_parameter: BlockNumber(10),
+                        step: BlockNumber(30),
+                    },)
+                },
+                epoch_settings
+            );
+        }
+
+        #[test]
+        fn fails_when_cardano_transactions_is_enabled_without_associated_config() {
+            let error = ServeCommandConfiguration {
+                cardano_transactions_signing_config: None,
+                signed_entity_types: Some(
+                    SignedEntityTypeDiscriminants::CardanoTransactions.to_string(),
+                ),
+                protocol_parameters: Some(fake_data::protocol_parameters()),
+                ..ServeCommandConfiguration::new_sample(temp_dir!())
+            }
+            .get_leader_aggregator_epoch_settings_configuration()
+            .unwrap_err();
+
+            assert!(
+                error
+                    .to_string()
+                    .contains("Configuration `cardano_transactions_signing_config` is mandatory")
+            );
+        }
+    }
+
     #[test]
     fn serialized_ancillary_files_signer_config_use_snake_case_for_keys_and_kebab_case_for_type_value()
      {

mithril-aggregator/src/database/migration.rs

@@ -251,5 +251,30 @@ alter table signed_entity add column epoch as (coalesce(json_extract(beacon, '$.
 create index signed_entity_epoch on signed_entity(epoch);
         "#,
         ),
+        // Migration 37
+        // Update `epoch_setting` table to make `cardano_transactions_signing_config` optional.
+        SqlMigration::new(
+            37,
+            r#"
+-- disable foreign keys since `signer_registration` have a foreign key constraint on `epoch_setting`
+pragma foreign_keys=false;
+
+create table if not exists new_epoch_setting (
+    epoch_setting_id                    integer     not null,
+    protocol_parameters                 json        not null,
+    cardano_transactions_signing_config json,
+    primary key (epoch_setting_id)
+);
+insert into new_epoch_setting (epoch_setting_id, protocol_parameters, cardano_transactions_signing_config)
+    select epoch_setting_id, protocol_parameters, cardano_transactions_signing_config
+    from epoch_setting order by rowid asc;
+drop table epoch_setting;
+alter table new_epoch_setting rename to epoch_setting;
+
+-- reenable foreign keys
+pragma foreign_key_check;
+pragma foreign_keys=true;
+        "#,
+        ),
     ]
 }

mithril-aggregator/src/database/query/epoch_settings/get_epoch_settings.rs

@@ -69,10 +69,10 @@ mod tests {
         );
 
         assert_eq!(
-            CardanoTransactionsSigningConfig {
+            Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(10),
                 step: BlockNumber(15)
-            },
+            }),
             epoch_settings_record.cardano_transactions_signing_config
         );
 
@@ -86,10 +86,10 @@ mod tests {
             epoch_settings_record.protocol_parameters
         );
         assert_eq!(
-            CardanoTransactionsSigningConfig {
+            Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(30),
                 step: BlockNumber(15),
-            },
+            }),
             epoch_settings_record.cardano_transactions_signing_config
         );
 

mithril-aggregator/src/database/query/epoch_settings/insert_or_ignore_epoch_settings.rs

@@ -19,10 +19,10 @@ impl InsertOrIgnoreEpochSettingsQuery {
                     Value::String(
                         serde_json::to_string(&epoch_settings.protocol_parameters).unwrap(),
                     ),
-                    Value::String(
-                        serde_json::to_string(&epoch_settings.cardano_transactions_signing_config)
-                            .unwrap(),
-                    ),
+                    match &epoch_settings.cardano_transactions_signing_config {
+                        Some(config) => Value::String(serde_json::to_string(config).unwrap()),
+                        None => Value::Null,
+                    },
                 ],
             ),
         }
@@ -64,10 +64,10 @@ mod tests {
         let expected_epoch_settings = EpochSettingsRecord {
             epoch_settings_id: Epoch(3),
             protocol_parameters: fake_data::protocol_parameters(),
-            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+            cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(24),
                 step: BlockNumber(62),
-            },
+            }),
         };
         let record = connection
             .fetch_first(InsertOrIgnoreEpochSettingsQuery::one(
@@ -76,6 +76,19 @@ mod tests {
             .unwrap();
 
         assert_eq!(Some(expected_epoch_settings), record);
+
+        let expected_epoch_settings_without_ctx_config = EpochSettingsRecord {
+            epoch_settings_id: Epoch(4),
+            protocol_parameters: fake_data::protocol_parameters(),
+            cardano_transactions_signing_config: None,
+        };
+        let record = connection
+            .fetch_first(InsertOrIgnoreEpochSettingsQuery::one(
+                expected_epoch_settings_without_ctx_config.clone(),
+            ))
+            .unwrap();
+
+        assert_eq!(Some(expected_epoch_settings_without_ctx_config), record);
     }
 
     #[test]
@@ -85,10 +98,10 @@ mod tests {
         let expected_epoch_settings = EpochSettingsRecord {
             epoch_settings_id: Epoch(3),
             protocol_parameters: fake_data::protocol_parameters(),
-            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+            cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
                 security_parameter: BlockNumber(24),
                 step: BlockNumber(62),
-            },
+            }),
         };
         let record = connection
             .fetch_first(InsertOrIgnoreEpochSettingsQuery::one(
@@ -99,10 +112,10 @@ mod tests {
 
         let record = connection
             .fetch_first(InsertOrIgnoreEpochSettingsQuery::one(EpochSettingsRecord {
-                cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+                cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
                     security_parameter: BlockNumber(134),
                     step: BlockNumber(872),
-                },
+                }),
                 ..expected_epoch_settings.clone()
             }))
             .unwrap();

mithril-aggregator/src/database/record/epoch_settings.rs

@@ -13,7 +13,7 @@ pub struct EpochSettingsRecord {
     pub protocol_parameters: ProtocolParameters,
 
     /// Cardano transactions signing configuration.
-    pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
 
 impl From<EpochSettingsRecord> for AggregatorEpochSettings {
@@ -32,7 +32,7 @@ impl SqLiteEntity for EpochSettingsRecord {
     {
         let epoch_settings_id_int = row.read::<i64, _>(0);
         let protocol_parameters_string = &row.read::<&str, _>(1);
-        let cardano_transactions_signing_config_string = &row.read::<&str, _>(2);
+        let cardano_transactions_signing_config_string = &row.read::<Option<&str>, _>(2);
 
         let epoch_settings_record = Self {
             epoch_settings_id: Epoch(epoch_settings_id_int.try_into().map_err(|e| {
@@ -47,13 +47,13 @@ impl SqLiteEntity for EpochSettingsRecord {
                     ))
                 },
             )?,
-            cardano_transactions_signing_config: serde_json::from_str(cardano_transactions_signing_config_string).map_err(
+            cardano_transactions_signing_config: cardano_transactions_signing_config_string.map(|config| serde_json::from_str(config).map_err(
                 |e| {
                     HydrationError::InvalidData(format!(
-                        "Could not turn string '{cardano_transactions_signing_config_string}' to CardanoTransactionsSigningConfig. Error: {e}"
+                        "Could not turn string '{config}' to CardanoTransactionsSigningConfig. Error: {e}"
                     ))
                 },
-            )?,
+            )).transpose()?,
 
         };
 

mithril-aggregator/src/database/test_helper.rs

@@ -208,10 +208,7 @@ pub fn insert_epoch_settings(
         let (sql_values, _) = InsertOrIgnoreEpochSettingsQuery::one(EpochSettingsRecord {
             epoch_settings_id: Epoch(1),
             protocol_parameters: ProtocolParameters::new(1, 2, 1.0),
-            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
-                security_parameter: BlockNumber(0),
-                step: BlockNumber(0),
-            },
+            cardano_transactions_signing_config: None,
         })
         .filters()
         .expand();

mithril-aggregator/src/entities/aggregator_epoch_settings.rs

@@ -7,7 +7,7 @@ pub struct AggregatorEpochSettings {
     pub protocol_parameters: ProtocolParameters,
 
     /// Cardano transactions signing configuration
-    pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
 
 #[cfg(test)]
@@ -31,7 +31,7 @@ mod test_utils {
                 protocol_parameters: self.protocol_parameters,
                 enabled_signed_entity_types,
                 signed_entity_types_config: SignedEntityTypeConfiguration {
-                    cardano_transactions: Some(self.cardano_transactions_signing_config),
+                    cardano_transactions: self.cardano_transactions_signing_config,
                 },
             }
         }