feature(aggregator, openapi): introduce a new aggregator route to retrieve protocol settings by epoch

turmelclem · turmelclem · commit aa82f6cb2c68 · 2025-10-16T16:33:12.000+02:00
diff --git a/mithril-aggregator/src/dependency_injection/builder/enablers/misc.rs b/mithril-aggregator/src/dependency_injection/builder/enablers/misc.rs
@@ -41,11 +41,13 @@ impl DependenciesBuilder {
             self.get_sqlite_connection().await?,
         ));
         let signed_entity_storer = self.get_signed_entity_storer().await?;
+        let epoch_settings_storer = self.get_epoch_settings_store().await?;
         let immutable_file_digest_mapper = self.get_immutable_file_digest_mapper().await?;
         let epoch_service = self.get_epoch_service().await?;
         let service = MithrilMessageService::new(
             certificate_repository,
             signed_entity_storer,
+            epoch_settings_storer,
             immutable_file_digest_mapper,
             epoch_service,
         );
diff --git a/mithril-aggregator/src/http_server/routes/mod.rs b/mithril-aggregator/src/http_server/routes/mod.rs
@@ -3,6 +3,7 @@ mod certificate_routes;
 mod epoch_routes;
 mod middlewares;
 mod proof_routes;
+mod protocol_configuration_routes;
 pub(crate) mod reply;
 mod root_routes;
 pub mod router;
diff --git a/mithril-aggregator/src/http_server/routes/protocol_configuration_routes.rs b/mithril-aggregator/src/http_server/routes/protocol_configuration_routes.rs
@@ -0,0 +1,158 @@
+use warp::Filter;
+
+use crate::http_server::routes::middlewares;
+use crate::http_server::routes::router::RouterState;
+
+pub fn routes(
+    router_state: &RouterState,
+) -> impl Filter<Extract = (impl warp::Reply + use<>,), Error = warp::Rejection> + Clone + use<> {
+    protocol_configuration(router_state)
+}
+
+/// GET /protocol-configuration
+fn protocol_configuration(
+    router_state: &RouterState,
+) -> impl Filter<Extract = (impl warp::Reply + use<>,), Error = warp::Rejection> + Clone + use<> {
+    warp::path!("protocol-configuration" / String)
+        .and(warp::get())
+        .and(middlewares::with_logger(router_state))
+        .and(middlewares::with_http_message_service(router_state))
+        .and(middlewares::extract_config(router_state, |config| {
+            config.allowed_discriminants.clone()
+        }))
+        .and_then(handlers::protocol_configuration)
+}
+
+mod handlers {
+    use slog::{Logger, warn};
+    use std::{collections::BTreeSet, convert::Infallible, sync::Arc};
+
+    use mithril_common::entities::{Epoch, SignedEntityTypeDiscriminants};
+
+    use crate::{http_server::routes::reply, services::MessageService};
+
+    /// Protocol Configuration
+    pub async fn protocol_configuration(
+        epoch: String,
+        logger: Logger,
+        http_message_service: Arc<dyn MessageService>,
+        allowed_discriminants: BTreeSet<SignedEntityTypeDiscriminants>,
+    ) -> Result<impl warp::Reply, Infallible> {
+        let epoch = match epoch.parse::<u64>() {
+            Ok(epoch) => Epoch(epoch),
+            Err(err) => {
+                warn!(logger, "protocol_configuration::invalid_epoch"; "error" => ?err);
+                return Ok(reply::bad_request(
+                    "invalid_epoch".to_string(),
+                    err.to_string(),
+                ));
+            }
+        };
+
+        let protocol_configuration_message = http_message_service
+            .get_protocol_configuration_message(epoch, allowed_discriminants)
+            .await;
+
+        match protocol_configuration_message {
+            Ok(message) => Ok(reply::json(&message, warp::http::StatusCode::OK)),
+            Err(err) => {
+                slog::warn!(logger, "protocol_configuration::error"; "error" => ?err);
+                Ok(reply::server_error(err))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::anyhow;
+    use serde_json::Value::Null;
+    use std::sync::Arc;
+    use warp::{
+        http::{Method, StatusCode},
+        test::request,
+    };
+
+    use mithril_api_spec::APISpec;
+    use mithril_common::messages::ProtocolConfigurationMessage;
+    use mithril_common::test::double::Dummy;
+
+    use crate::{initialize_dependencies, services::MockMessageService};
+
+    use super::*;
+
+    fn setup_router(
+        state: RouterState,
+    ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+        let cors = warp::cors()
+            .allow_any_origin()
+            .allow_headers(vec!["content-type"])
+            .allow_methods(vec![Method::GET, Method::POST, Method::OPTIONS]);
+
+        warp::any().and(routes(&state).with(cors))
+    }
+
+    #[tokio::test]
+    async fn test_protocol_configuration_get_ok() {
+        let method = Method::GET.as_str();
+        let base_path = "/protocol-configuration";
+        let mut dependency_manager = initialize_dependencies!().await;
+        let mut mock_http_message_service = MockMessageService::new();
+        mock_http_message_service
+            .expect_get_protocol_configuration_message()
+            .return_once(|_, _| Ok(ProtocolConfigurationMessage::dummy()))
+            .once();
+        dependency_manager.message_service = Arc::new(mock_http_message_service);
+
+        let response = request()
+            .method(method)
+            .path(&format!("{base_path}/42"))
+            .reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
+                dependency_manager,
+            ))))
+            .await;
+
+        APISpec::verify_conformity(
+            APISpec::get_default_spec_file_from(crate::http_server::API_SPEC_LOCATION),
+            method,
+            &format!("{base_path}/{{epoch}}"),
+            "application/json",
+            &Null,
+            &response,
+            &StatusCode::OK,
+        )
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_protocol_configuration_get_ko_500() {
+        let method = Method::GET.as_str();
+        let base_path = "/protocol-configuration";
+        let mut dependency_manager = initialize_dependencies!().await;
+        let mut mock_http_message_service = MockMessageService::new();
+        mock_http_message_service
+            .expect_get_protocol_configuration_message()
+            .return_once(|_, _| Err(anyhow!("an error")))
+            .once();
+        dependency_manager.message_service = Arc::new(mock_http_message_service);
+
+        let response = request()
+            .method(method)
+            .path(&format!("{base_path}/42"))
+            .reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
+                dependency_manager,
+            ))))
+            .await;
+
+        APISpec::verify_conformity(
+            APISpec::get_default_spec_file_from(crate::http_server::API_SPEC_LOCATION),
+            method,
+            &format!("{base_path}/{{epoch}}"),
+            "application/json",
+            &Null,
+            &response,
+            &StatusCode::INTERNAL_SERVER_ERROR,
+        )
+        .unwrap();
+    }
+}
diff --git a/mithril-aggregator/src/services/message.rs b/mithril-aggregator/src/services/message.rs
@@ -14,13 +14,13 @@ use mithril_common::{
         CardanoStakeDistributionListMessage, CardanoStakeDistributionMessage,
         CardanoTransactionSnapshotListMessage, CardanoTransactionSnapshotMessage,
         CertificateListMessage, CertificateMessage, EpochSettingsMessage,
-        MithrilStakeDistributionListMessage, MithrilStakeDistributionMessage, SignerMessagePart,
-        SnapshotListMessage, SnapshotMessage,
+        MithrilStakeDistributionListMessage, MithrilStakeDistributionMessage,
+        ProtocolConfigurationMessage, SignerMessagePart, SnapshotListMessage, SnapshotMessage,
     },
 };
 
 use crate::{
-    ImmutableFileDigestMapper,
+    EpochSettingsStorer, ImmutableFileDigestMapper,
     database::repository::{CertificateRepository, SignedEntityStorer},
     dependency_injection::EpochServiceWrapper,
 };
@@ -35,6 +35,13 @@ pub trait MessageService: Sync + Send {
         allowed_discriminants: BTreeSet<SignedEntityTypeDiscriminants>,
     ) -> StdResult<EpochSettingsMessage>;
 
+    ///Return the protocol configuration message for the given epoch if it exists.
+    async fn get_protocol_configuration_message(
+        &self,
+        epoch: Epoch,
+        allowed_discriminants: BTreeSet<SignedEntityTypeDiscriminants>,
+    ) -> StdResult<ProtocolConfigurationMessage>;
+
     /// Return the message representation of a certificate if it exists.
     async fn get_certificate_message(
         &self,
@@ -130,6 +137,7 @@ pub trait MessageService: Sync + Send {
 pub struct MithrilMessageService {
     certificate_repository: Arc<CertificateRepository>,
     signed_entity_storer: Arc<dyn SignedEntityStorer>,
+    epoch_settings_storer: Arc<dyn EpochSettingsStorer>,
     immutable_file_digest_mapper: Arc<dyn ImmutableFileDigestMapper>,
     epoch_service: EpochServiceWrapper,
 }
@@ -139,12 +147,14 @@ impl MithrilMessageService {
     pub fn new(
         certificate_repository: Arc<CertificateRepository>,
         signed_entity_storer: Arc<dyn SignedEntityStorer>,
+        epoch_settings_storer: Arc<dyn EpochSettingsStorer>,
         immutable_file_digest_mapper: Arc<dyn ImmutableFileDigestMapper>,
         epoch_service: EpochServiceWrapper,
     ) -> Self {
         Self {
             certificate_repository,
             signed_entity_storer,
+            epoch_settings_storer,
             immutable_file_digest_mapper,
             epoch_service,
         }
@@ -184,6 +194,27 @@ impl MessageService for MithrilMessageService {
         Ok(epoch_settings_message)
     }
 
+    async fn get_protocol_configuration_message(
+        &self,
+        epoch: Epoch,
+        enabled_discriminants: BTreeSet<SignedEntityTypeDiscriminants>,
+    ) -> StdResult<ProtocolConfigurationMessage> {
+        let epoch_settings = self.epoch_settings_storer.get_epoch_settings(epoch).await?.unwrap();
+
+        let cardano_transactions_discriminant =
+            enabled_discriminants.get(&SignedEntityTypeDiscriminants::CardanoTransactions);
+
+        let cardano_transactions_signing_config = cardano_transactions_discriminant
+            .map(|_| epoch_settings.cardano_transactions_signing_config);
+
+        let protocol_configuration_message = ProtocolConfigurationMessage {
+            protocol_parameters: epoch_settings.protocol_parameters,
+            cardano_transactions_signing_config,
+            available_signed_entity_types: enabled_discriminants,
+        };
+        Ok(protocol_configuration_message)
+    }
+
     async fn get_certificate_message(
         &self,
         certificate_hash: &str,
@@ -362,7 +393,9 @@ mod tests {
     use tokio::sync::RwLock;
 
     use crate::database::record::SignedEntityRecord;
-    use crate::database::repository::{ImmutableFileDigestRepository, SignedEntityStore};
+    use crate::database::repository::{
+        EpochSettingsStore, ImmutableFileDigestRepository, SignedEntityStore,
+    };
     use crate::database::test_helper::main_db_connection;
     use crate::services::FakeEpochService;
 
@@ -419,6 +452,7 @@ mod tests {
             let connection = Arc::new(main_db_connection().unwrap());
             let certificate_repository = CertificateRepository::new(connection.clone());
             let signed_entity_store = SignedEntityStore::new(connection.clone());
+            let epoch_settings_storer = EpochSettingsStore::new(connection.clone(), None);
             let immutable_file_digest_mapper =
                 ImmutableFileDigestRepository::new(connection.clone());
             let epoch_service = self.epoch_service.unwrap_or(FakeEpochService::without_data());
@@ -444,6 +478,7 @@ mod tests {
             MithrilMessageService::new(
                 Arc::new(certificate_repository),
                 Arc::new(signed_entity_store),
+                Arc::new(epoch_settings_storer),
                 Arc::new(immutable_file_digest_mapper),
                 Arc::new(RwLock::new(epoch_service)),
             )
diff --git a/mithril-common/src/messages/mod.rs b/mithril-common/src/messages/mod.rs
@@ -18,6 +18,7 @@ mod interface;
 mod message_parts;
 mod mithril_stake_distribution;
 mod mithril_stake_distribution_list;
+mod protocol_configuration;
 mod register_signature;
 mod register_signer;
 mod snapshot;
@@ -61,6 +62,7 @@ pub use mithril_stake_distribution::MithrilStakeDistributionMessage;
 pub use mithril_stake_distribution_list::{
     MithrilStakeDistributionListItemMessage, MithrilStakeDistributionListMessage,
 };
+pub use protocol_configuration::ProtocolConfigurationMessage;
 pub use register_signature::{RegisterSignatureMessageDmq, RegisterSignatureMessageHttp};
 pub use register_signer::RegisterSignerMessage;
 pub use snapshot::SnapshotMessage;
diff --git a/mithril-common/src/messages/protocol_configuration.rs b/mithril-common/src/messages/protocol_configuration.rs
@@ -0,0 +1,21 @@
+use std::collections::BTreeSet;
+
+use serde::{Deserialize, Serialize};
+
+use crate::entities::{
+    CardanoTransactionsSigningConfig, Epoch, ProtocolParameters, SignedEntityTypeDiscriminants,
+};
+
+/// ProtocolConfiguration represents the protocol configuration of an epoch
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProtocolConfigurationMessage {
+    /// Signer Registration Protocol parameters
+    pub protocol_parameters: ProtocolParameters,
+
+    /// Cardano transactions signing configuration for the current epoch
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
+
+    /// Aggregator enabled signed entity types
+    pub available_signed_entity_types: BTreeSet<SignedEntityTypeDiscriminants>,
+}
diff --git a/mithril-common/src/test/double/dummies.rs b/mithril-common/src/test/double/dummies.rs
@@ -420,6 +420,23 @@ mod messages {
         }
     }
 
+    impl Dummy for ProtocolConfigurationMessage {
+        /// Return a dummy [ProtocolConfigurationMessage] (test-only).
+        fn dummy() -> Self {
+            Self {
+                protocol_parameters: ProtocolParameters {
+                    k: 5,
+                    m: 100,
+                    phi_f: 0.65,
+                },
+                cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig::dummy()),
+                available_signed_entity_types: BTreeSet::from([
+                    SignedEntityTypeDiscriminants::MithrilStakeDistribution,
+                ]),
+            }
+        }
+    }
+
     impl Dummy for MithrilStakeDistributionMessage {
         /// Return a dummy [MithrilStakeDistributionMessage] (test-only).
         fn dummy() -> Self {
diff --git a/openapi.yaml b/openapi.yaml
