mithril_signer/runtime/
runner.rs

1use anyhow::Context;
2use async_trait::async_trait;
3use slog::{Logger, debug, warn};
4use thiserror::Error;
5use tokio::sync::RwLockReadGuard;
6
7use mithril_common::StdResult;
8use mithril_common::crypto_helper::{KesPeriod, OpCert, ProtocolOpCert, SerDeShelleyFileFormat};
9use mithril_common::entities::{
10    Epoch, PartyId, ProtocolMessage, SignedEntityType, Signer, TimePoint,
11};
12use mithril_common::logging::LoggerExtensions;
13
14use crate::Configuration;
15use crate::dependency_injection::SignerDependencyContainer;
16use crate::entities::{BeaconToSign, SignerEpochSettings};
17use crate::services::{EpochService, MithrilProtocolInitializerBuilder};
18
19/// This trait is mainly intended for mocking.
20#[async_trait]
21pub trait Runner: Send + Sync {
22    /// Fetch the current epoch settings if any.
23    async fn get_epoch_settings(&self) -> StdResult<Option<SignerEpochSettings>>;
24
25    /// Fetch the beacon to sign if any.
26    async fn get_beacon_to_sign(&self, time_point: TimePoint) -> StdResult<Option<BeaconToSign>>;
27
28    /// Fetch the current time point from the Cardano node.
29    async fn get_current_time_point(&self) -> StdResult<TimePoint>;
30
31    /// Register the signer verification key to the aggregator.
32    async fn register_signer_to_aggregator(&self) -> StdResult<()>;
33
34    /// Read the stake distribution and store it.
35    async fn update_stake_distribution(&self, epoch: Epoch) -> StdResult<()>;
36
37    /// Check if the signer can sign the current epoch.
38    async fn can_sign_current_epoch(&self) -> StdResult<bool>;
39
40    /// Register epoch information
41    async fn inform_epoch_settings(&self, epoch_settings: SignerEpochSettings) -> StdResult<()>;
42
43    /// Create the message to be signed with the single signature.
44    async fn compute_message(
45        &self,
46        signed_entity_type: &SignedEntityType,
47    ) -> StdResult<ProtocolMessage>;
48
49    /// Create the single signature.
50    async fn compute_publish_single_signature(
51        &self,
52        beacon_to_sign: &BeaconToSign,
53        message: &ProtocolMessage,
54    ) -> StdResult<()>;
55
56    /// Read the current era and update the EraChecker.
57    async fn update_era_checker(&self, epoch: Epoch) -> StdResult<()>;
58
59    /// Perform the upkeep tasks.
60    async fn upkeep(&self, current_epoch: Epoch) -> StdResult<()>;
61}
62
63/// This type represents the errors thrown from the Runner.
64#[derive(Debug, Clone, PartialEq, Eq, Error)]
65pub enum RunnerError {
66    /// Value was expected from a subsystem but None was returned.
67    #[error("No value returned by the subsystem for `{0}`.")]
68    NoValueError(String),
69    /// Could not associate my node with a stake.
70    #[error("No stake associated with myself.")]
71    NoStakeForSelf(),
72    /// Could not find the stake for one of the signers.
73    #[error("No stake associated with this signer, party_id: {0}.")]
74    NoStakeForSigner(PartyId),
75    /// Parse file error
76    #[error("File parse failed: {0}.")]
77    FileParse(String),
78}
79
80/// Controller methods for the Signer's state machine.
81pub struct SignerRunner {
82    config: Configuration,
83    services: SignerDependencyContainer,
84    logger: Logger,
85}
86
87impl SignerRunner {
88    /// Create a new Runner instance.
89    pub fn new(config: Configuration, services: SignerDependencyContainer, logger: Logger) -> Self {
90        Self {
91            services,
92            config,
93            logger: logger.new_with_component_name::<Self>(),
94        }
95    }
96
97    async fn epoch_service_read(&self) -> RwLockReadGuard<'_, dyn EpochService> {
98        self.services.epoch_service.read().await
99    }
100}
101
102#[cfg_attr(test, mockall::automock)]
103#[async_trait]
104impl Runner for SignerRunner {
105    async fn get_epoch_settings(&self) -> StdResult<Option<SignerEpochSettings>> {
106        debug!(self.logger, ">> get_epoch_settings");
107
108        self.services
109            .certificate_handler
110            .retrieve_epoch_settings()
111            .await
112            .map_err(|e| e.into())
113    }
114
115    async fn get_beacon_to_sign(&self, time_point: TimePoint) -> StdResult<Option<BeaconToSign>> {
116        debug!(
117            self.logger,
118            ">> get_beacon_to_sign(time_point: {time_point})"
119        );
120
121        self.services.certifier.get_beacon_to_sign(time_point).await
122    }
123
124    async fn get_current_time_point(&self) -> StdResult<TimePoint> {
125        debug!(self.logger, ">> get_current_time_point");
126
127        self.services
128            .ticker_service
129            .get_current_time_point()
130            .await
131            .with_context(|| "Runner can not get current time point")
132    }
133
134    async fn register_signer_to_aggregator(&self) -> StdResult<()> {
135        debug!(self.logger, ">> register_signer_to_aggregator");
136
137        let (epoch, protocol_parameters) = {
138            let epoch_service = self.services.epoch_service.read().await;
139            let epoch = epoch_service.epoch_of_current_data()?;
140            let protocol_parameters = epoch_service.registration_protocol_parameters()?;
141
142            (epoch, protocol_parameters.clone())
143        };
144
145        let epoch_offset_to_recording_epoch = epoch.offset_to_recording_epoch();
146        let stake_distribution = self
147            .services
148            .stake_store
149            .get_stakes(epoch_offset_to_recording_epoch)
150            .await?
151            .ok_or_else(|| {
152                RunnerError::NoValueError(format!(
153                    "stakes at epoch {epoch_offset_to_recording_epoch}"
154                ))
155            })?;
156        let stake = stake_distribution
157            .get(&self.services.single_signer.get_party_id())
158            .ok_or_else(RunnerError::NoStakeForSelf)?;
159        let (operational_certificate, protocol_operational_certificate) = match &self
160            .config
161            .operational_certificate_path
162        {
163            Some(operational_certificate_path) => {
164                let opcert: OpCert = OpCert::from_file(operational_certificate_path)
165                    .map_err(|_| RunnerError::FileParse("operational_certificate_path".to_string()))
166                    .with_context(
167                        || "register_signer_to_aggregator can not decode OpCert from file",
168                    )?;
169                (Some(opcert.clone()), Some(ProtocolOpCert::new(opcert)))
170            }
171            _ => (None, None),
172        };
173
174        let kes_period = match operational_certificate {
175            Some(operational_certificate) => Some(
176                self.services
177                    .chain_observer
178                    .get_current_kes_period(&operational_certificate)
179                    .await?
180                    .unwrap_or_default()
181                    - operational_certificate.start_kes_period as KesPeriod,
182            ),
183            None => None,
184        };
185        let protocol_initializer = MithrilProtocolInitializerBuilder::build(
186            stake,
187            &protocol_parameters,
188            self.services.kes_signer.clone(),
189            kes_period,
190        )?;
191        let signer = Signer::new(
192            self.services.single_signer.get_party_id(),
193            protocol_initializer.verification_key().into(),
194            protocol_initializer.verification_key_signature(),
195            protocol_operational_certificate,
196            kes_period,
197        );
198        self.services
199            .certificate_handler
200            .register_signer(epoch_offset_to_recording_epoch, &signer)
201            .await?;
202        self.services
203            .protocol_initializer_store
204            .save_protocol_initializer(epoch_offset_to_recording_epoch, protocol_initializer)
205            .await?;
206
207        Ok(())
208    }
209
210    async fn update_stake_distribution(&self, epoch: Epoch) -> StdResult<()> {
211        debug!(self.logger, ">> update_stake_distribution(epoch: {epoch})");
212
213        let exists_stake_distribution = !self
214            .services
215            .stake_store
216            .get_stakes(epoch.offset_to_recording_epoch())
217            .await?
218            .unwrap_or_default()
219            .is_empty();
220        if exists_stake_distribution {
221            return Ok(());
222        }
223
224        let stake_distribution = self
225            .services
226            .chain_observer
227            .get_current_stake_distribution()
228            .await?
229            .ok_or_else(|| RunnerError::NoValueError("current_stake_distribution".to_string()))?;
230        self.services
231            .stake_store
232            .save_stakes(epoch.offset_to_recording_epoch(), stake_distribution)
233            .await?;
234
235        Ok(())
236    }
237
238    async fn can_sign_current_epoch(&self) -> StdResult<bool> {
239        let epoch_service = self.epoch_service_read().await;
240        epoch_service.can_signer_sign_current_epoch(self.services.single_signer.get_party_id())
241    }
242
243    async fn inform_epoch_settings(&self, epoch_settings: SignerEpochSettings) -> StdResult<()> {
244        debug!(
245            self.logger,
246            ">> inform_epoch_settings(epoch:{})", epoch_settings.epoch
247        );
248        let aggregator_features = self
249            .services
250            .certificate_handler
251            .retrieve_aggregator_features()
252            .await?;
253
254        self.services
255            .epoch_service
256            .write()
257            .await
258            .inform_epoch_settings(
259                epoch_settings,
260                aggregator_features.capabilities.signed_entity_types,
261            )
262            .await
263    }
264
265    async fn compute_message(
266        &self,
267        signed_entity_type: &SignedEntityType,
268    ) -> StdResult<ProtocolMessage> {
269        debug!(self.logger, ">> compute_message({signed_entity_type:?})");
270
271        let protocol_message = self
272            .services
273            .signable_builder_service
274            .compute_protocol_message(signed_entity_type.to_owned())
275            .await
276            .with_context(|| format!("Runner can not compute protocol message for signed entity type: '{signed_entity_type}'"))?;
277
278        Ok(protocol_message)
279    }
280
281    async fn compute_publish_single_signature(
282        &self,
283        beacon_to_sign: &BeaconToSign,
284        message: &ProtocolMessage,
285    ) -> StdResult<()> {
286        debug!(self.logger, ">> compute_publish_single_signature"; "beacon_to_sign" => ?beacon_to_sign);
287        self.services
288            .certifier
289            .compute_publish_single_signature(beacon_to_sign, message)
290            .await
291    }
292
293    async fn update_era_checker(&self, epoch: Epoch) -> StdResult<()> {
294        debug!(self.logger, ">> update_era_checker(epoch:{epoch})");
295
296        let era_token = self
297            .services
298            .era_reader
299            .read_era_epoch_token(epoch)
300            .await
301            .map_err(Box::new)?;
302        let current_era = era_token.get_current_supported_era()?;
303        self.services
304            .era_checker
305            .change_era(current_era, era_token.get_current_epoch());
306        debug!(
307            self.logger,
308            "Current Era is {} (Epoch {}).",
309            current_era,
310            era_token.get_current_epoch()
311        );
312
313        if era_token.get_next_supported_era().is_err() {
314            let era_name = &era_token.get_next_era_marker().unwrap().name;
315            warn!(
316                self.logger,
317                "Upcoming Era '{era_name}' is not supported by this version of the software. Please update!"
318            );
319        }
320
321        Ok(())
322    }
323
324    async fn upkeep(&self, current_epoch: Epoch) -> StdResult<()> {
325        debug!(self.logger, ">> upkeep(current_epoch:{current_epoch})");
326        self.services.upkeep_service.run(current_epoch).await?;
327        Ok(())
328    }
329}
330
331#[cfg(test)]
332mod tests {
333    use mockall::mock;
334    use mockall::predicate::eq;
335    use std::collections::BTreeSet;
336    use std::{path::Path, sync::Arc};
337    use tokio::sync::RwLock;
338
339    use mithril_cardano_node_chain::test::double::{DumbBlockScanner, FakeChainObserver};
340    use mithril_cardano_node_internal_database::{
341        signable_builder::{
342            CardanoDatabaseSignableBuilder, CardanoImmutableFilesFullSignableBuilder,
343        },
344        test::double::{DumbImmutableDigester, DumbImmutableFileObserver},
345    };
346    use mithril_common::{
347        api_version::APIVersionProvider,
348        crypto_helper::{MKMap, MKMapNode, MKTreeNode, MKTreeStoreInMemory, MKTreeStorer},
349        entities::{BlockNumber, BlockRange, Epoch, SignedEntityTypeDiscriminants},
350        messages::{AggregatorCapabilities, AggregatorFeaturesMessage},
351        signable_builder::{
352            BlockRangeRootRetriever, CardanoStakeDistributionSignableBuilder,
353            CardanoTransactionsSignableBuilder, MithrilSignableBuilderService,
354            MithrilStakeDistributionSignableBuilder, SignableBuilderServiceDependencies,
355        },
356        test_utils::{MithrilFixtureBuilder, fake_data},
357    };
358    use mithril_era::{EraChecker, EraReader, adapters::EraReaderBootstrapAdapter};
359    use mithril_signed_entity_lock::SignedEntityTypeLock;
360    use mithril_signed_entity_preloader::{
361        CardanoTransactionsPreloader, CardanoTransactionsPreloaderActivation,
362    };
363    use mithril_ticker::{MithrilTickerService, TickerService};
364
365    use crate::database::repository::{
366        ProtocolInitializerRepository, SignedBeaconRepository, StakePoolStore,
367    };
368    use crate::database::test_helper::main_db_connection;
369    use crate::metrics::MetricsService;
370    use crate::services::{
371        CardanoTransactionsImporter, DumbAggregatorClient, MithrilEpochService,
372        MithrilSingleSigner, MockTransactionStore, MockUpkeepService, SignerCertifierService,
373        SignerSignableSeedBuilder, SignerSignedEntityConfigProvider,
374    };
375    use crate::test_tools::TestLogger;
376
377    use super::*;
378
379    const DIGESTER_RESULT: &str = "a digest";
380
381    mock! {
382        pub FakeTimePointProvider { }
383
384        #[async_trait]
385        impl TickerService for FakeTimePointProvider {
386            async fn get_current_time_point(&self) -> StdResult<TimePoint>;
387        }
388    }
389
390    mock! {
391        pub BlockRangeRootRetrieverImpl<S: MKTreeStorer> { }
392
393        #[async_trait]
394        impl<S: MKTreeStorer> BlockRangeRootRetriever<S> for BlockRangeRootRetrieverImpl<S> {
395            async fn retrieve_block_range_roots<'a>(
396                &'a self,
397                up_to_beacon: BlockNumber,
398            ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)> + 'a>>;
399
400            async fn compute_merkle_map_from_block_range_roots(
401                &self,
402                up_to_beacon: BlockNumber,
403            ) -> StdResult<MKMap<BlockRange, MKMapNode<BlockRange,S>, S>>;
404        }
405    }
406
407    async fn init_services() -> SignerDependencyContainer {
408        let logger = TestLogger::stdout();
409        let sqlite_connection = Arc::new(main_db_connection().unwrap());
410        let stake_distribution_signers = fake_data::signers_with_stakes(2);
411        let party_id = stake_distribution_signers[1].party_id.clone();
412        let fake_observer = FakeChainObserver::default();
413        fake_observer.set_signers(stake_distribution_signers).await;
414        let chain_observer = Arc::new(fake_observer);
415        let ticker_service = Arc::new(MithrilTickerService::new(
416            chain_observer.clone(),
417            Arc::new(DumbImmutableFileObserver::default()),
418        ));
419        let era_reader = Arc::new(EraReader::new(Arc::new(EraReaderBootstrapAdapter)));
420        let era_epoch_token = era_reader
421            .read_era_epoch_token(ticker_service.get_current_epoch().await.unwrap())
422            .await
423            .unwrap();
424        let era_checker = Arc::new(EraChecker::new(
425            era_epoch_token.get_current_supported_era().unwrap(),
426            era_epoch_token.get_current_epoch(),
427        ));
428
429        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
430        let digester = Arc::new(DumbImmutableDigester::default().with_digest(DIGESTER_RESULT));
431        let cardano_immutable_signable_builder =
432            Arc::new(CardanoImmutableFilesFullSignableBuilder::new(
433                digester.clone(),
434                Path::new(""),
435                logger.clone(),
436            ));
437        let mithril_stake_distribution_signable_builder =
438            Arc::new(MithrilStakeDistributionSignableBuilder::default());
439        let transaction_parser = Arc::new(DumbBlockScanner::new());
440        let transaction_store = Arc::new(MockTransactionStore::new());
441        let transactions_importer = Arc::new(CardanoTransactionsImporter::new(
442            transaction_parser.clone(),
443            transaction_store.clone(),
444            logger.clone(),
445        ));
446        let block_range_root_retriever =
447            Arc::new(MockBlockRangeRootRetrieverImpl::<MKTreeStoreInMemory>::new());
448        let cardano_transactions_builder = Arc::new(CardanoTransactionsSignableBuilder::new(
449            transactions_importer.clone(),
450            block_range_root_retriever,
451        ));
452        let stake_store = Arc::new(StakePoolStore::new(sqlite_connection.clone(), None));
453        let cardano_stake_distribution_builder = Arc::new(
454            CardanoStakeDistributionSignableBuilder::new(stake_store.clone()),
455        );
456        let cardano_database_signable_builder = Arc::new(CardanoDatabaseSignableBuilder::new(
457            digester.clone(),
458            Path::new(""),
459            logger.clone(),
460        ));
461        let protocol_initializer_store = Arc::new(ProtocolInitializerRepository::new(
462            sqlite_connection.clone(),
463            None,
464        ));
465        let epoch_service = Arc::new(RwLock::new(MithrilEpochService::new(
466            stake_store.clone(),
467            protocol_initializer_store.clone(),
468            logger.clone(),
469        )));
470        let single_signer = Arc::new(MithrilSingleSigner::new(
471            party_id,
472            epoch_service.clone(),
473            logger.clone(),
474        ));
475        let signable_seed_builder_service = Arc::new(SignerSignableSeedBuilder::new(
476            epoch_service.clone(),
477            protocol_initializer_store.clone(),
478        ));
479        let signable_builders_dependencies = SignableBuilderServiceDependencies::new(
480            mithril_stake_distribution_signable_builder,
481            cardano_immutable_signable_builder,
482            cardano_transactions_builder,
483            cardano_stake_distribution_builder,
484            cardano_database_signable_builder,
485        );
486        let signable_builder_service = Arc::new(MithrilSignableBuilderService::new(
487            signable_seed_builder_service,
488            signable_builders_dependencies,
489            logger.clone(),
490        ));
491        let metrics_service = Arc::new(MetricsService::new(logger.clone()).unwrap());
492        let signed_entity_type_lock = Arc::new(SignedEntityTypeLock::default());
493        let security_parameter = BlockNumber(0);
494        let cardano_transactions_preloader = Arc::new(CardanoTransactionsPreloader::new(
495            signed_entity_type_lock.clone(),
496            transactions_importer.clone(),
497            security_parameter,
498            chain_observer.clone(),
499            logger.clone(),
500            Arc::new(CardanoTransactionsPreloaderActivation::new(true)),
501        ));
502        let upkeep_service = Arc::new(MockUpkeepService::new());
503        let aggregator_client = Arc::new(DumbAggregatorClient::default());
504        let certifier = Arc::new(SignerCertifierService::new(
505            Arc::new(SignedBeaconRepository::new(sqlite_connection.clone(), None)),
506            Arc::new(SignerSignedEntityConfigProvider::new(epoch_service.clone())),
507            signed_entity_type_lock.clone(),
508            single_signer.clone(),
509            aggregator_client.clone(),
510            logger.clone(),
511        ));
512        let kes_signer = None;
513
514        SignerDependencyContainer {
515            stake_store,
516            certificate_handler: aggregator_client,
517            chain_observer,
518            digester,
519            single_signer,
520            ticker_service,
521            protocol_initializer_store,
522            era_checker,
523            era_reader,
524            api_version_provider,
525            signable_builder_service,
526            metrics_service,
527            signed_entity_type_lock,
528            cardano_transactions_preloader,
529            upkeep_service,
530            epoch_service,
531            certifier,
532            kes_signer,
533        }
534    }
535
536    async fn init_runner(
537        maybe_services: Option<SignerDependencyContainer>,
538        maybe_config: Option<Configuration>,
539    ) -> SignerRunner {
540        SignerRunner::new(
541            maybe_config.unwrap_or(Configuration::new_sample("1")),
542            maybe_services.unwrap_or(init_services().await),
543            TestLogger::stdout(),
544        )
545    }
546
547    #[tokio::test]
548    async fn test_get_current_time_point() {
549        let mut services = init_services().await;
550        let expected = TimePoint::dummy();
551        let mut ticker_service = MockFakeTimePointProvider::new();
552        ticker_service
553            .expect_get_current_time_point()
554            .once()
555            .returning(move || Ok(TimePoint::dummy()));
556        services.ticker_service = Arc::new(ticker_service);
557        let runner = init_runner(Some(services), None).await;
558
559        assert_eq!(
560            expected,
561            runner
562                .get_current_time_point()
563                .await
564                .expect("Get current time point should not fail.")
565        );
566    }
567
568    #[tokio::test]
569    async fn test_update_stake_distribution() {
570        let services = init_services().await;
571        let stake_store = services.stake_store.clone();
572        let current_epoch = services
573            .chain_observer
574            .get_current_epoch()
575            .await
576            .expect("chain observer should not fail")
577            .expect("the observer should return an epoch");
578        let runner = init_runner(Some(services), None).await;
579        assert!(
580            stake_store
581                .get_stakes(current_epoch)
582                .await
583                .expect("getting stakes from store should not fail")
584                .is_none()
585        );
586
587        runner
588            .update_stake_distribution(current_epoch)
589            .await
590            .expect("update_stake_distribution should not fail.");
591
592        let stake_distribution = stake_store
593            .get_stakes(current_epoch.offset_to_recording_epoch())
594            .await
595            .expect("getting stakes from store should not fail")
596            .expect("there should be stakes for this epoch");
597
598        assert_eq!(2, stake_distribution.len());
599    }
600
601    #[tokio::test]
602    async fn test_register_signer_to_aggregator() {
603        let mut services = init_services().await;
604        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
605        let certificate_handler = Arc::new(DumbAggregatorClient::default());
606        services.certificate_handler = certificate_handler.clone();
607        let protocol_initializer_store = services.protocol_initializer_store.clone();
608        let current_epoch = services.ticker_service.get_current_epoch().await.unwrap();
609
610        let stakes = services
611            .chain_observer
612            .get_current_stake_distribution()
613            .await
614            .unwrap()
615            .unwrap();
616        services
617            .stake_store
618            .save_stakes(current_epoch.offset_to_recording_epoch(), stakes)
619            .await
620            .unwrap();
621
622        let runner = init_runner(Some(services), None).await;
623        // inform epoch settings
624        let epoch_settings = SignerEpochSettings {
625            epoch: current_epoch,
626            current_signers: fixture.signers(),
627            next_signers: fixture.signers(),
628            ..SignerEpochSettings::dummy().clone()
629        };
630        runner.inform_epoch_settings(epoch_settings).await.unwrap();
631
632        runner
633            .register_signer_to_aggregator()
634            .await
635            .expect("registering a signer to the aggregator should not fail");
636
637        assert!(certificate_handler.get_last_registered_signer().await.is_some());
638        let maybe_protocol_initializer = protocol_initializer_store
639            .get_protocol_initializer(current_epoch.offset_to_recording_epoch())
640            .await
641            .expect("get_protocol_initializer should not fail");
642        assert!(
643            maybe_protocol_initializer.is_some(),
644            "A protocol initializer should have been registered at the 'Recording' epoch"
645        );
646    }
647
648    #[tokio::test]
649    async fn test_update_era_checker() {
650        let services = init_services().await;
651        let ticker_service = services.ticker_service.clone();
652        let era_checker = services.era_checker.clone();
653        let mut time_point = ticker_service.get_current_time_point().await.unwrap();
654
655        assert_eq!(time_point.epoch, era_checker.current_epoch());
656        let runner = init_runner(Some(services), None).await;
657        time_point.epoch += 1;
658        runner.update_era_checker(time_point.epoch).await.unwrap();
659
660        assert_eq!(time_point.epoch, era_checker.current_epoch());
661    }
662
663    #[tokio::test]
664    async fn test_upkeep() {
665        let mut services = init_services().await;
666        let mut upkeep_service_mock = MockUpkeepService::new();
667        upkeep_service_mock
668            .expect_run()
669            .with(eq(Epoch(17)))
670            .returning(|_| Ok(()))
671            .once();
672        services.upkeep_service = Arc::new(upkeep_service_mock);
673
674        let runner = init_runner(Some(services), None).await;
675        runner.upkeep(Epoch(17)).await.expect("upkeep should not fail");
676    }
677
678    #[tokio::test]
679    async fn test_inform_epoch_setting_pass_allowed_discriminant_to_epoch_service() {
680        let mut services = init_services().await;
681        let certificate_handler = Arc::new(DumbAggregatorClient::default());
682        certificate_handler
683            .set_aggregator_features(AggregatorFeaturesMessage {
684                capabilities: AggregatorCapabilities {
685                    signed_entity_types: BTreeSet::from([
686                        SignedEntityTypeDiscriminants::MithrilStakeDistribution,
687                        SignedEntityTypeDiscriminants::CardanoTransactions,
688                    ]),
689                    ..AggregatorFeaturesMessage::dummy().capabilities
690                },
691                ..AggregatorFeaturesMessage::dummy()
692            })
693            .await;
694        services.certificate_handler = certificate_handler;
695        let runner = init_runner(Some(services), None).await;
696
697        let epoch_settings = SignerEpochSettings {
698            epoch: Epoch(1),
699            ..SignerEpochSettings::dummy()
700        };
701        runner.inform_epoch_settings(epoch_settings).await.unwrap();
702
703        let epoch_service = runner.services.epoch_service.read().await;
704        let recorded_allowed_discriminants = epoch_service.allowed_discriminants().unwrap();
705
706        assert_eq!(
707            &BTreeSet::from([
708                SignedEntityTypeDiscriminants::MithrilStakeDistribution,
709                SignedEntityTypeDiscriminants::CardanoTransactions,
710            ]),
711            recorded_allowed_discriminants
712        );
713    }
714}
mithril_signer/runtime/runner.rs

mithril_signer/runtime/
runner.rs
