mithril_signer/services/cardano_transactions/
preloader_checker.rs

1use std::sync::Arc;
2
3use anyhow::Context;
4use async_trait::async_trait;
5
6use mithril_common::{StdResult, entities::SignedEntityTypeDiscriminants};
7use mithril_signed_entity_preloader::CardanoTransactionsPreloaderChecker;
8
9use crate::services::AggregatorClient;
10
11/// CardanoTransactionsPreloaderActivationSigner
12pub struct CardanoTransactionsPreloaderActivationSigner {
13    aggregator_client: Arc<dyn AggregatorClient>,
14}
15
16impl CardanoTransactionsPreloaderActivationSigner {
17    /// Create a new instance of `CardanoTransactionsPreloaderActivationSigner`
18    pub fn new(aggregator_client: Arc<dyn AggregatorClient>) -> Self {
19        Self { aggregator_client }
20    }
21}
22
23#[async_trait]
24impl CardanoTransactionsPreloaderChecker for CardanoTransactionsPreloaderActivationSigner {
25    async fn is_activated(&self) -> StdResult<bool> {
26        let message = self
27            .aggregator_client
28            .retrieve_aggregator_features()
29            .await
30            .with_context(|| "An error occurred while calling the Aggregator")?;
31
32        let activated_signed_entity_types = message.capabilities.signed_entity_types;
33
34        Ok(activated_signed_entity_types
35            .contains(&SignedEntityTypeDiscriminants::CardanoTransactions))
36    }
37}
38
39#[cfg(test)]
40mod tests {
41    use anyhow::anyhow;
42    use std::collections::BTreeSet;
43
44    use mithril_common::{
45        entities::SignedEntityTypeDiscriminants, messages::AggregatorFeaturesMessage,
46        test::double::Dummy,
47    };
48
49    use crate::services::{AggregatorClientError, MockAggregatorClient};
50
51    use super::*;
52
53    #[tokio::test]
54    async fn preloader_activation_state_activate_preloader_when_cardano_transactions_not_in_aggregator_capabilities()
55     {
56        let mut aggregator_client = MockAggregatorClient::new();
57        aggregator_client
58            .expect_retrieve_aggregator_features()
59            .times(1)
60            .returning(|| {
61                let mut message = AggregatorFeaturesMessage::dummy();
62                message.capabilities.signed_entity_types =
63                    BTreeSet::from([SignedEntityTypeDiscriminants::MithrilStakeDistribution]);
64                Ok(message)
65            });
66        let preloader =
67            CardanoTransactionsPreloaderActivationSigner::new(Arc::new(aggregator_client));
68
69        let is_activated = preloader.is_activated().await.unwrap();
70
71        assert!(!is_activated);
72    }
73
74    #[tokio::test]
75    async fn preloader_activation_state_activate_preloader_when_cardano_transactions_in_aggregator_capabilities()
76     {
77        let mut aggregator_client = MockAggregatorClient::new();
78        aggregator_client
79            .expect_retrieve_aggregator_features()
80            .times(1)
81            .returning(|| {
82                let mut message = AggregatorFeaturesMessage::dummy();
83                message.capabilities.signed_entity_types =
84                    BTreeSet::from([SignedEntityTypeDiscriminants::CardanoTransactions]);
85                Ok(message)
86            });
87        let preloader =
88            CardanoTransactionsPreloaderActivationSigner::new(Arc::new(aggregator_client));
89
90        let is_activated = preloader.is_activated().await.unwrap();
91
92        assert!(is_activated);
93    }
94
95    #[tokio::test]
96    async fn preloader_activation_state_activate_preloader_when_aggregator_call_fails() {
97        let mut aggregator_client = MockAggregatorClient::new();
98        aggregator_client
99            .expect_retrieve_aggregator_features()
100            .times(1)
101            .returning(|| {
102                Err(AggregatorClientError::RemoteServerTechnical(anyhow!(
103                    "Aggregator call failed"
104                )))
105            });
106        let preloader =
107            CardanoTransactionsPreloaderActivationSigner::new(Arc::new(aggregator_client));
108
109        preloader
110            .is_activated()
111            .await
112            .expect_err("Should fail due to aggregator call failure");
113    }
114}