fix(aggregator): CSD epoch missing offset when expanding latest

Cardano Stake Distribution signed entities are created with an offset of
`-1` to the epoch, this must be reflected to the epoch expansion when
using `latest` (with or without additional offset).
Else querying with `latest` will always returns a `404`.

Author: Alenar

mithril-aggregator/src/http_server/routes/artifact_routes/cardano_database.rs

@@ -115,7 +115,7 @@ mod handlers {
         http_message_service: Arc<dyn MessageService>,
         max_artifact_epoch_offset: u32,
     ) -> Result<impl warp::Reply, Infallible> {
-        let (expanded_epoch, offset) = match parameters::expand_epoch(&epoch, epoch_service).await {
+        let expanded_epoch = match parameters::expand_epoch(&epoch, epoch_service).await {
             Ok(epoch) => epoch,
             Err(err) => {
                 warn!(logger,"list_by_epoch_artifacts_cardano_database::invalid_epoch"; "error" => ?err);
@@ -126,7 +126,7 @@ mod handlers {
             }
         };
 
-        if offset.is_some_and(|o| o > max_artifact_epoch_offset as u64) {
+        if expanded_epoch.has_offset_greater_than(max_artifact_epoch_offset as u64) {
             return Ok(reply::bad_request(
                 "invalid_epoch".to_string(),
                 format!(
@@ -136,7 +136,7 @@ mod handlers {
         }
 
         match http_message_service
-            .get_cardano_database_list_message_by_epoch(LIST_MAX_ITEMS, expanded_epoch)
+            .get_cardano_database_list_message_by_epoch(LIST_MAX_ITEMS, *expanded_epoch)
             .await
         {
             Ok(message) => Ok(reply::json(&message, StatusCode::OK)),

mithril-aggregator/src/http_server/routes/artifact_routes/cardano_stake_distribution.rs

@@ -130,7 +130,7 @@ pub mod handlers {
                 client_metadata.client_type.as_deref().unwrap_or_default(),
             ]);
 
-        let (expanded_epoch, offset) = match parameters::expand_epoch(&epoch, epoch_service).await {
+        let expanded_epoch = match parameters::expand_epoch(&epoch, epoch_service).await {
             Ok(epoch) => epoch,
             Err(err) => {
                 warn!(logger, "get_artifact_by_epoch::invalid_epoch"; "error" => ?err);
@@ -141,7 +141,7 @@ pub mod handlers {
             }
         };
 
-        if offset.is_some_and(|o| o > max_artifact_epoch_offset as u64) {
+        if expanded_epoch.has_offset_greater_than(max_artifact_epoch_offset as u64) {
             return Ok(reply::bad_request(
                 "invalid_epoch".to_string(),
                 format!(
@@ -151,7 +151,10 @@ pub mod handlers {
         }
 
         match http_message_service
-            .get_cardano_stake_distribution_message_by_epoch(expanded_epoch)
+            .get_cardano_stake_distribution_message_by_epoch(
+                // Reminder: Cardano stake distribution is recorded with a `-1` epoch offset
+                expanded_epoch.apply_offset_for_latest(1),
+            )
             .await
         {
             Ok(Some(message)) => Ok(reply::json(&message, StatusCode::OK)),

mithril-aggregator/src/http_server/routes/middlewares.rs

@@ -210,41 +210,84 @@ pub mod validators {
 
 pub mod parameters {
     use anyhow::Context;
+    use std::ops::Deref;
 
     use mithril_common::StdResult;
 
     use super::*;
 
+    /// An epoch parsed from a http request parameter
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub enum ExpandedEpoch {
+        /// Epoch was explicitly provided as a number (e.g., "123")
+        Parsed(Epoch),
+        /// Epoch was provided as "latest" (e.g., "latest")
+        Latest(Epoch),
+        /// Epoch was provided as "latest-{offset}" (e.g., "latest-100")
+        LatestMinusOffset(Epoch, u64),
+    }
+
+    impl Deref for ExpandedEpoch {
+        type Target = Epoch;
+
+        fn deref(&self) -> &Self::Target {
+            match self {
+                ExpandedEpoch::Parsed(epoch)
+                | ExpandedEpoch::Latest(epoch)
+                | ExpandedEpoch::LatestMinusOffset(epoch, _) => epoch,
+            }
+        }
+    }
+
+    impl ExpandedEpoch {
+        /// Returns true if this epoch was expanded from 'latest-{offset}' and the offset
+        /// is greater than the given value.
+        pub fn has_offset_greater_than(&self, value: u64) -> bool {
+            match self {
+                ExpandedEpoch::Parsed(_) | ExpandedEpoch::Latest(_) => false,
+                ExpandedEpoch::LatestMinusOffset(_, offset) => offset > &value,
+            }
+        }
+
+        /// Apply an additional negative offset to the epoch, but only if it was derived from 'latest'.
+        pub fn apply_offset_for_latest(&self, additional_offset: u64) -> Epoch {
+            match self {
+                ExpandedEpoch::Parsed(epoch) => *epoch,
+                ExpandedEpoch::Latest(epoch) | ExpandedEpoch::LatestMinusOffset(epoch, ..) => {
+                    Epoch(epoch.saturating_sub(additional_offset))
+                }
+            }
+        }
+    }
+
     /// Parse the string into an [Epoch] if it's a number, or if it's 'latest{-{offset}}' expand
     /// into the actual epoch minus the optional given offset.
     ///
     /// Return the expanded epoch and the eventual offset that was applied
     pub async fn expand_epoch(
         epoch_str: &str,
         epoch_service: EpochServiceWrapper,
-    ) -> StdResult<(Epoch, Option<u64>)> {
+    ) -> StdResult<ExpandedEpoch> {
         let epoch_str = epoch_str.to_lowercase();
         if epoch_str == "latest" {
             epoch_service
                 .read()
                 .await
                 .epoch_of_current_data()
-                .map(|epoch| (epoch, None))
+                .map(ExpandedEpoch::Latest)
         } else if epoch_str.starts_with("latest-") {
             let (_, offset_str) = epoch_str.split_at(7);
             let offset = offset_str
                 .parse::<u64>()
                 .with_context(|| "Invalid epoch offset: must be a number")?;
 
-            epoch_service
-                .read()
-                .await
-                .epoch_of_current_data()
-                .map(|epoch| (Epoch(epoch.saturating_sub(offset)), Some(offset)))
+            epoch_service.read().await.epoch_of_current_data().map(|epoch| {
+                ExpandedEpoch::LatestMinusOffset(Epoch(epoch.saturating_sub(offset)), offset)
+            })
         } else {
             epoch_str
                 .parse::<u64>()
-                .map(|epoch| (Epoch(epoch), None))
+                .map(|epoch| ExpandedEpoch::Parsed(Epoch(epoch)))
                 .with_context(|| "Invalid epoch: must be a number or 'latest'")
         }
     }
@@ -409,7 +452,7 @@ mod tests {
 
         use crate::services::FakeEpochServiceBuilder;
 
-        use super::*;
+        use super::{parameters::ExpandedEpoch, *};
 
         fn fake_epoch_service(returned_epoch: Epoch) -> EpochServiceWrapper {
             Arc::new(RwLock::new(
@@ -422,15 +465,15 @@ mod tests {
             let epoch_service = fake_epoch_service(Epoch(300));
             let expanded_epoch = parameters::expand_epoch("456", epoch_service).await.unwrap();
 
-            assert_eq!(expanded_epoch, (Epoch(456), None));
+            assert_eq!(expanded_epoch, ExpandedEpoch::Parsed(Epoch(456)));
         }
 
         #[tokio::test]
         async fn use_epoch_service_current_epoch_if_latest() {
             let epoch_service = fake_epoch_service(Epoch(89));
             let expanded_epoch = parameters::expand_epoch("latest", epoch_service).await.unwrap();
 
-            assert_eq!(expanded_epoch, (Epoch(89), None));
+            assert_eq!(expanded_epoch, ExpandedEpoch::Latest(Epoch(89)));
         }
 
         #[tokio::test]
@@ -439,10 +482,16 @@ mod tests {
             let expanded_epoch = parameters::expand_epoch("latest-13", epoch_service.clone())
                 .await
                 .unwrap();
-            assert_eq!(expanded_epoch, (Epoch(76), Some(13)));
+            assert_eq!(
+                expanded_epoch,
+                ExpandedEpoch::LatestMinusOffset(Epoch(76), 13)
+            );
 
             let expanded_epoch = parameters::expand_epoch("latest-0", epoch_service).await.unwrap();
-            assert_eq!(expanded_epoch, (Epoch(89), Some(0)));
+            assert_eq!(
+                expanded_epoch,
+                ExpandedEpoch::LatestMinusOffset(Epoch(89), 0)
+            );
         }
 
         #[tokio::test]
@@ -472,7 +521,38 @@ mod tests {
                     .await
                     .unwrap();
 
-            assert_eq!(expanded_epoch, (Epoch(0), Some(u64::MAX)));
+            assert_eq!(
+                expanded_epoch,
+                ExpandedEpoch::LatestMinusOffset(Epoch(0), u64::MAX)
+            );
+        }
+
+        #[test]
+        fn test_expanded_epoch_is_parsed_offset_greater_than() {
+            assert!(!ExpandedEpoch::Parsed(Epoch(90)).has_offset_greater_than(15));
+            assert!(!ExpandedEpoch::Latest(Epoch(90)).has_offset_greater_than(15));
+            assert!(!ExpandedEpoch::LatestMinusOffset(Epoch(90), 10).has_offset_greater_than(10));
+            assert!(ExpandedEpoch::LatestMinusOffset(Epoch(90), 11).has_offset_greater_than(10));
+        }
+
+        #[test]
+        fn test_expanded_epoch_apply_additional_offset() {
+            assert_eq!(
+                ExpandedEpoch::Parsed(Epoch(90)).apply_offset_for_latest(15),
+                Epoch(90)
+            );
+            assert_eq!(
+                ExpandedEpoch::Latest(Epoch(90)).apply_offset_for_latest(15),
+                Epoch(75)
+            );
+            assert_eq!(
+                ExpandedEpoch::LatestMinusOffset(Epoch(90), 13).apply_offset_for_latest(15),
+                Epoch(75)
+            );
+            assert_eq!(
+                ExpandedEpoch::Latest(Epoch(90)).apply_offset_for_latest(u64::MAX),
+                Epoch(0)
+            );
         }
     }
 }

mithril-aggregator/src/http_server/routes/signer_routes.rs

@@ -178,26 +178,25 @@ mod handlers {
         epoch_service: EpochServiceWrapper,
         verification_key_store: Arc<dyn VerificationKeyStorer>,
     ) -> Result<impl warp::Reply, Infallible> {
-        let (registered_at_epoch, _offset) =
-            match parameters::expand_epoch(&registered_at, epoch_service).await {
-                Ok(epoch) => epoch,
-                Err(err) => {
-                    warn!(logger,"registered_signers::invalid_epoch"; "error" => ?err);
-                    return Ok(reply::bad_request(
-                        "invalid_epoch".to_string(),
-                        err.to_string(),
-                    ));
-                }
-            };
+        let expanded_epoch = match parameters::expand_epoch(&registered_at, epoch_service).await {
+            Ok(epoch) => epoch,
+            Err(err) => {
+                warn!(logger,"registered_signers::invalid_epoch"; "error" => ?err);
+                return Ok(reply::bad_request(
+                    "invalid_epoch".to_string(),
+                    err.to_string(),
+                ));
+            }
+        };
 
         // The given epoch is the epoch at which the signer registered, the store works on
-        // the recording epoch so we need to offset.
+        // the recording epoch, so we need to offset.
         match verification_key_store
-            .get_signers(registered_at_epoch.offset_to_recording_epoch())
+            .get_signers(expanded_epoch.offset_to_recording_epoch())
             .await
         {
             Ok(Some(signers)) => {
-                let message = SignerRegistrationsMessage::new(registered_at_epoch, signers);
+                let message = SignerRegistrationsMessage::new(*expanded_epoch, signers);
                 Ok(reply::json(&message, StatusCode::OK))
             }
             Ok(None) => {