mithril_signer/runtime/
runner.rs

1use anyhow::Context;
2use async_trait::async_trait;
3use slog::{debug, warn, Logger};
4use thiserror::Error;
5use tokio::sync::RwLockReadGuard;
6
7use mithril_common::crypto_helper::{KESPeriod, OpCert, ProtocolOpCert, SerDeShelleyFileFormat};
8use mithril_common::entities::{
9    Epoch, PartyId, ProtocolMessage, SignedEntityType, Signer, TimePoint,
10};
11use mithril_common::logging::LoggerExtensions;
12use mithril_common::StdResult;
13
14use crate::dependency_injection::SignerDependencyContainer;
15use crate::entities::{BeaconToSign, SignerEpochSettings};
16use crate::services::{EpochService, MithrilProtocolInitializerBuilder};
17use crate::Configuration;
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.config.kes_secret_key_path.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!(self.logger, "Upcoming Era '{era_name}' is not supported by this version of the software. Please update!");
316        }
317
318        Ok(())
319    }
320
321    async fn upkeep(&self, current_epoch: Epoch) -> StdResult<()> {
322        debug!(self.logger, ">> upkeep(current_epoch:{current_epoch})");
323        self.services.upkeep_service.run(current_epoch).await?;
324        Ok(())
325    }
326}
327
328#[cfg(test)]
329mod tests {
330    use mithril_common::signable_builder::{
331        CardanoDatabaseSignableBuilder, SignableBuilderServiceDependencies,
332    };
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_common::{
340        api_version::APIVersionProvider,
341        cardano_block_scanner::DumbBlockScanner,
342        chain_observer::FakeObserver,
343        crypto_helper::{MKMap, MKMapNode, MKTreeNode, MKTreeStoreInMemory, MKTreeStorer},
344        digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
345        entities::{BlockNumber, BlockRange, Epoch, SignedEntityTypeDiscriminants},
346        era::{adapters::EraReaderBootstrapAdapter, EraChecker, EraReader},
347        messages::{AggregatorCapabilities, AggregatorFeaturesMessage},
348        signable_builder::{
349            BlockRangeRootRetriever, CardanoImmutableFilesFullSignableBuilder,
350            CardanoStakeDistributionSignableBuilder, CardanoTransactionsSignableBuilder,
351            MithrilSignableBuilderService, MithrilStakeDistributionSignableBuilder,
352        },
353        test_utils::{fake_data, MithrilFixtureBuilder},
354        MithrilTickerService, TickerService,
355    };
356    use mithril_signed_entity_lock::SignedEntityTypeLock;
357    use mithril_signed_entity_preloader::{
358        CardanoTransactionsPreloader, CardanoTransactionsPreloaderActivation,
359    };
360
361    use crate::database::repository::{
362        ProtocolInitializerRepository, SignedBeaconRepository, StakePoolStore,
363    };
364    use crate::database::test_helper::main_db_connection;
365    use crate::metrics::MetricsService;
366    use crate::services::{
367        CardanoTransactionsImporter, DumbAggregatorClient, MithrilEpochService,
368        MithrilSingleSigner, MockTransactionStore, MockUpkeepService, SignerCertifierService,
369        SignerSignableSeedBuilder, SignerSignedEntityConfigProvider,
370    };
371    use crate::test_tools::TestLogger;
372
373    use super::*;
374
375    const DIGESTER_RESULT: &str = "a digest";
376
377    mock! {
378        pub FakeTimePointProvider { }
379
380        #[async_trait]
381        impl TickerService for FakeTimePointProvider {
382            async fn get_current_time_point(&self) -> StdResult<TimePoint>;
383        }
384    }
385
386    mock! {
387        pub BlockRangeRootRetrieverImpl<S: MKTreeStorer> { }
388
389        #[async_trait]
390        impl<S: MKTreeStorer> BlockRangeRootRetriever<S> for BlockRangeRootRetrieverImpl<S> {
391            async fn retrieve_block_range_roots<'a>(
392                &'a self,
393                up_to_beacon: BlockNumber,
394            ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)> + 'a>>;
395
396            async fn compute_merkle_map_from_block_range_roots(
397                &self,
398                up_to_beacon: BlockNumber,
399            ) -> StdResult<MKMap<BlockRange, MKMapNode<BlockRange,S>, S>>;
400        }
401    }
402
403    async fn init_services() -> SignerDependencyContainer {
404        let logger = TestLogger::stdout();
405        let sqlite_connection = Arc::new(main_db_connection().unwrap());
406        let stake_distribution_signers = fake_data::signers_with_stakes(2);
407        let party_id = stake_distribution_signers[1].party_id.clone();
408        let fake_observer = FakeObserver::default();
409        fake_observer.set_signers(stake_distribution_signers).await;
410        let chain_observer = Arc::new(fake_observer);
411        let ticker_service = Arc::new(MithrilTickerService::new(
412            chain_observer.clone(),
413            Arc::new(DumbImmutableFileObserver::default()),
414        ));
415        let era_reader = Arc::new(EraReader::new(Arc::new(EraReaderBootstrapAdapter)));
416        let era_epoch_token = era_reader
417            .read_era_epoch_token(ticker_service.get_current_epoch().await.unwrap())
418            .await
419            .unwrap();
420        let era_checker = Arc::new(EraChecker::new(
421            era_epoch_token.get_current_supported_era().unwrap(),
422            era_epoch_token.get_current_epoch(),
423        ));
424
425        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
426        let digester = Arc::new(DumbImmutableDigester::default().with_digest(DIGESTER_RESULT));
427        let cardano_immutable_signable_builder =
428            Arc::new(CardanoImmutableFilesFullSignableBuilder::new(
429                digester.clone(),
430                Path::new(""),
431                logger.clone(),
432            ));
433        let mithril_stake_distribution_signable_builder =
434            Arc::new(MithrilStakeDistributionSignableBuilder::default());
435        let transaction_parser = Arc::new(DumbBlockScanner::new());
436        let transaction_store = Arc::new(MockTransactionStore::new());
437        let transactions_importer = Arc::new(CardanoTransactionsImporter::new(
438            transaction_parser.clone(),
439            transaction_store.clone(),
440            logger.clone(),
441        ));
442        let block_range_root_retriever =
443            Arc::new(MockBlockRangeRootRetrieverImpl::<MKTreeStoreInMemory>::new());
444        let cardano_transactions_builder = Arc::new(CardanoTransactionsSignableBuilder::new(
445            transactions_importer.clone(),
446            block_range_root_retriever,
447        ));
448        let stake_store = Arc::new(StakePoolStore::new(sqlite_connection.clone(), None));
449        let cardano_stake_distribution_builder = Arc::new(
450            CardanoStakeDistributionSignableBuilder::new(stake_store.clone()),
451        );
452        let cardano_database_signable_builder = Arc::new(CardanoDatabaseSignableBuilder::new(
453            digester.clone(),
454            Path::new(""),
455            logger.clone(),
456        ));
457        let protocol_initializer_store = Arc::new(ProtocolInitializerRepository::new(
458            sqlite_connection.clone(),
459            None,
460        ));
461        let epoch_service = Arc::new(RwLock::new(MithrilEpochService::new(
462            stake_store.clone(),
463            protocol_initializer_store.clone(),
464            logger.clone(),
465        )));
466        let single_signer = Arc::new(MithrilSingleSigner::new(
467            party_id,
468            epoch_service.clone(),
469            logger.clone(),
470        ));
471        let signable_seed_builder_service = Arc::new(SignerSignableSeedBuilder::new(
472            epoch_service.clone(),
473            protocol_initializer_store.clone(),
474        ));
475        let signable_builders_dependencies = SignableBuilderServiceDependencies::new(
476            mithril_stake_distribution_signable_builder,
477            cardano_immutable_signable_builder,
478            cardano_transactions_builder,
479            cardano_stake_distribution_builder,
480            cardano_database_signable_builder,
481        );
482        let signable_builder_service = Arc::new(MithrilSignableBuilderService::new(
483            signable_seed_builder_service,
484            signable_builders_dependencies,
485            logger.clone(),
486        ));
487        let metrics_service = Arc::new(MetricsService::new(logger.clone()).unwrap());
488        let signed_entity_type_lock = Arc::new(SignedEntityTypeLock::default());
489        let security_parameter = BlockNumber(0);
490        let cardano_transactions_preloader = Arc::new(CardanoTransactionsPreloader::new(
491            signed_entity_type_lock.clone(),
492            transactions_importer.clone(),
493            security_parameter,
494            chain_observer.clone(),
495            logger.clone(),
496            Arc::new(CardanoTransactionsPreloaderActivation::new(true)),
497        ));
498        let upkeep_service = Arc::new(MockUpkeepService::new());
499        let aggregator_client = Arc::new(DumbAggregatorClient::default());
500        let certifier = Arc::new(SignerCertifierService::new(
501            Arc::new(SignedBeaconRepository::new(sqlite_connection.clone(), None)),
502            Arc::new(SignerSignedEntityConfigProvider::new(epoch_service.clone())),
503            signed_entity_type_lock.clone(),
504            single_signer.clone(),
505            aggregator_client.clone(),
506            logger.clone(),
507        ));
508
509        SignerDependencyContainer {
510            stake_store,
511            certificate_handler: aggregator_client,
512            chain_observer,
513            digester,
514            single_signer,
515            ticker_service,
516            protocol_initializer_store,
517            era_checker,
518            era_reader,
519            api_version_provider,
520            signable_builder_service,
521            metrics_service,
522            signed_entity_type_lock,
523            cardano_transactions_preloader,
524            upkeep_service,
525            epoch_service,
526            certifier,
527        }
528    }
529
530    async fn init_runner(
531        maybe_services: Option<SignerDependencyContainer>,
532        maybe_config: Option<Configuration>,
533    ) -> SignerRunner {
534        SignerRunner::new(
535            maybe_config.unwrap_or(Configuration::new_sample("1")),
536            maybe_services.unwrap_or(init_services().await),
537            TestLogger::stdout(),
538        )
539    }
540
541    #[tokio::test]
542    async fn test_get_current_time_point() {
543        let mut services = init_services().await;
544        let expected = TimePoint::dummy();
545        let mut ticker_service = MockFakeTimePointProvider::new();
546        ticker_service
547            .expect_get_current_time_point()
548            .once()
549            .returning(move || Ok(TimePoint::dummy()));
550        services.ticker_service = Arc::new(ticker_service);
551        let runner = init_runner(Some(services), None).await;
552
553        assert_eq!(
554            expected,
555            runner
556                .get_current_time_point()
557                .await
558                .expect("Get current time point should not fail.")
559        );
560    }
561
562    #[tokio::test]
563    async fn test_update_stake_distribution() {
564        let services = init_services().await;
565        let stake_store = services.stake_store.clone();
566        let current_epoch = services
567            .chain_observer
568            .get_current_epoch()
569            .await
570            .expect("chain observer should not fail")
571            .expect("the observer should return an epoch");
572        let runner = init_runner(Some(services), None).await;
573        assert!(stake_store
574            .get_stakes(current_epoch)
575            .await
576            .expect("getting stakes from store should not fail")
577            .is_none());
578
579        runner
580            .update_stake_distribution(current_epoch)
581            .await
582            .expect("update_stake_distribution should not fail.");
583
584        let stake_distribution = stake_store
585            .get_stakes(current_epoch.offset_to_recording_epoch())
586            .await
587            .expect("getting stakes from store should not fail")
588            .expect("there should be stakes for this epoch");
589
590        assert_eq!(2, stake_distribution.len());
591    }
592
593    #[tokio::test]
594    async fn test_register_signer_to_aggregator() {
595        let mut services = init_services().await;
596        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
597        let certificate_handler = Arc::new(DumbAggregatorClient::default());
598        services.certificate_handler = certificate_handler.clone();
599        let protocol_initializer_store = services.protocol_initializer_store.clone();
600        let current_epoch = services.ticker_service.get_current_epoch().await.unwrap();
601
602        let stakes = services
603            .chain_observer
604            .get_current_stake_distribution()
605            .await
606            .unwrap()
607            .unwrap();
608        services
609            .stake_store
610            .save_stakes(current_epoch.offset_to_recording_epoch(), stakes)
611            .await
612            .unwrap();
613
614        let runner = init_runner(Some(services), None).await;
615        // inform epoch settings
616        let epoch_settings = SignerEpochSettings {
617            epoch: current_epoch,
618            current_signers: fixture.signers(),
619            next_signers: fixture.signers(),
620            ..SignerEpochSettings::dummy().clone()
621        };
622        runner.inform_epoch_settings(epoch_settings).await.unwrap();
623
624        runner
625            .register_signer_to_aggregator()
626            .await
627            .expect("registering a signer to the aggregator should not fail");
628
629        assert!(certificate_handler
630            .get_last_registered_signer()
631            .await
632            .is_some());
633        let maybe_protocol_initializer = protocol_initializer_store
634            .get_protocol_initializer(current_epoch.offset_to_recording_epoch())
635            .await
636            .expect("get_protocol_initializer should not fail");
637        assert!(
638            maybe_protocol_initializer.is_some(),
639            "A protocol initializer should have been registered at the 'Recording' epoch"
640        );
641    }
642
643    #[tokio::test]
644    async fn test_update_era_checker() {
645        let services = init_services().await;
646        let ticker_service = services.ticker_service.clone();
647        let era_checker = services.era_checker.clone();
648        let mut time_point = ticker_service.get_current_time_point().await.unwrap();
649
650        assert_eq!(time_point.epoch, era_checker.current_epoch());
651        let runner = init_runner(Some(services), None).await;
652        time_point.epoch += 1;
653        runner.update_era_checker(time_point.epoch).await.unwrap();
654
655        assert_eq!(time_point.epoch, era_checker.current_epoch());
656    }
657
658    #[tokio::test]
659    async fn test_upkeep() {
660        let mut services = init_services().await;
661        let mut upkeep_service_mock = MockUpkeepService::new();
662        upkeep_service_mock
663            .expect_run()
664            .with(eq(Epoch(17)))
665            .returning(|_| Ok(()))
666            .once();
667        services.upkeep_service = Arc::new(upkeep_service_mock);
668
669        let runner = init_runner(Some(services), None).await;
670        runner
671            .upkeep(Epoch(17))
672            .await
673            .expect("upkeep should not fail");
674    }
675
676    #[tokio::test]
677    async fn test_inform_epoch_setting_pass_allowed_discriminant_to_epoch_service() {
678        let mut services = init_services().await;
679        let certificate_handler = Arc::new(DumbAggregatorClient::default());
680        certificate_handler
681            .set_aggregator_features(AggregatorFeaturesMessage {
682                capabilities: AggregatorCapabilities {
683                    signed_entity_types: BTreeSet::from([
684                        SignedEntityTypeDiscriminants::MithrilStakeDistribution,
685                        SignedEntityTypeDiscriminants::CardanoTransactions,
686                    ]),
687                    ..AggregatorFeaturesMessage::dummy().capabilities
688                },
689                ..AggregatorFeaturesMessage::dummy()
690            })
691            .await;
692        services.certificate_handler = certificate_handler;
693        let runner = init_runner(Some(services), None).await;
694
695        let epoch_settings = SignerEpochSettings {
696            epoch: Epoch(1),
697            ..SignerEpochSettings::dummy()
698        };
699        runner.inform_epoch_settings(epoch_settings).await.unwrap();
700
701        let epoch_service = runner.services.epoch_service.read().await;
702        let recorded_allowed_discriminants = epoch_service.allowed_discriminants().unwrap();
703
704        assert_eq!(
705            &BTreeSet::from([
706                SignedEntityTypeDiscriminants::MithrilStakeDistribution,
707                SignedEntityTypeDiscriminants::CardanoTransactions,
708            ]),
709            recorded_allowed_discriminants
710        );
711    }
712}
mithril_signer/runtime/runner.rs

mithril_signer/runtime/
runner.rs
