mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs

1use anyhow::Context;
2use std::sync::Arc;
3
4use mithril_common::certificate_chain::{CertificateVerifier, MithrilCertificateVerifier};
5use mithril_common::crypto_helper::{
6    ProtocolGenesisSigner, ProtocolGenesisVerificationKey, ProtocolGenesisVerifier,
7};
8
9use crate::database::repository::{BufferedSingleSignatureRepository, SingleSignatureRepository};
10use crate::dependency_injection::{DependenciesBuilder, DependenciesBuilderError, Result};
11use crate::get_dependency;
12use crate::services::{
13    BufferedCertifierService, CertifierService, MithrilCertifierService,
14    MithrilSignerRegistrationFollower, SignerSynchronizer,
15};
16use crate::{
17    ExecutionEnvironment, MithrilSignerRegistrationLeader, MithrilSignerRegistrationVerifier,
18    MultiSigner, MultiSignerImpl, SignerRegisterer, SignerRegistrationRoundOpener,
19    SignerRegistrationVerifier, SingleSignatureAuthenticator,
20};
21
22/// Retrieve the mithril_signer_registration according to the configuration.
23/// The macro is used because we are not able to return different kind of trait using a function.
24macro_rules! get_mithril_signer_registration {
25    ($self:ident) => {{
26        if $self.configuration.is_follower_aggregator() {
27            $self.get_mithril_signer_registration_follower().await?
28        } else {
29            $self.get_mithril_signer_registration_leader().await?
30        }
31    }};
32}
33
34impl DependenciesBuilder {
35    /// Create [CertifierService] service
36    pub async fn build_certifier_service(&mut self) -> Result<Arc<dyn CertifierService>> {
37        let cardano_network = self.configuration.get_network().with_context(|| {
38            "Dependencies Builder can not get Cardano network while building the chain observer"
39        })?;
40        let sqlite_connection = self.get_sqlite_connection().await?;
41        let open_message_repository = self.get_open_message_repository().await?;
42        let single_signature_repository =
43            Arc::new(SingleSignatureRepository::new(sqlite_connection.clone()));
44        let certificate_repository = self.get_certificate_repository().await?;
45        let certificate_verifier = self.get_certificate_verifier().await?;
46        let genesis_verifier = self.get_genesis_verifier().await?;
47        let multi_signer = self.get_multi_signer().await?;
48        let epoch_service = self.get_epoch_service().await?;
49        let logger = self.root_logger();
50
51        let certifier = Arc::new(MithrilCertifierService::new(
52            cardano_network,
53            open_message_repository,
54            single_signature_repository,
55            certificate_repository,
56            certificate_verifier,
57            genesis_verifier,
58            multi_signer,
59            epoch_service,
60            logger,
61        ));
62
63        Ok(Arc::new(BufferedCertifierService::new(
64            certifier,
65            Arc::new(BufferedSingleSignatureRepository::new(sqlite_connection)),
66            self.root_logger(),
67        )))
68    }
69
70    /// [CertifierService] service
71    pub async fn get_certifier_service(&mut self) -> Result<Arc<dyn CertifierService>> {
72        get_dependency!(self.certifier_service)
73    }
74
75    async fn build_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>> {
76        let multi_signer =
77            MultiSignerImpl::new(self.get_epoch_service().await?, self.root_logger());
78
79        Ok(Arc::new(multi_signer))
80    }
81
82    /// Get a configured multi signer
83    pub async fn get_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>> {
84        get_dependency!(self.multi_signer)
85    }
86
87    async fn build_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
88        let verifier = Arc::new(MithrilCertificateVerifier::new(
89            self.root_logger(),
90            self.get_certificate_repository().await?,
91        ));
92
93        Ok(verifier)
94    }
95
96    /// [CertificateVerifier] service.
97    pub async fn get_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
98        get_dependency!(self.certificate_verifier)
99    }
100
101    async fn build_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
102        let genesis_verifier: ProtocolGenesisVerifier = match self.configuration.environment() {
103            ExecutionEnvironment::Production => ProtocolGenesisVerifier::from_verification_key(
104                ProtocolGenesisVerificationKey::from_json_hex(
105                    &self.configuration.genesis_verification_key(),
106                )
107                .map_err(|e| DependenciesBuilderError::Initialization {
108                    message: format!(
109                        "Could not decode hex key to build genesis verifier: '{}'",
110                        self.configuration.genesis_verification_key()
111                    ),
112                    error: Some(e),
113                })?,
114            ),
115            _ => ProtocolGenesisSigner::create_deterministic_signer().create_verifier(),
116        };
117
118        Ok(Arc::new(genesis_verifier))
119    }
120
121    /// Return a [ProtocolGenesisVerifier]
122    pub async fn get_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
123        get_dependency!(self.genesis_verifier)
124    }
125
126    /// Return a [MithrilSignerRegistrationLeader] service
127    async fn build_mithril_signer_registration_leader(
128        &mut self,
129    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
130        let registerer = MithrilSignerRegistrationLeader::new(
131            self.get_verification_key_store().await?,
132            self.get_signer_store().await?,
133            self.get_signer_registration_verifier().await?,
134        );
135
136        Ok(Arc::new(registerer))
137    }
138
139    /// Return a [MithrilSignerRegistrationLeader]
140    pub async fn get_mithril_signer_registration_leader(
141        &mut self,
142    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
143        get_dependency!(self.mithril_signer_registration_leader)
144    }
145
146    /// Return a [MithrilSignerRegistrationFollower] service
147    async fn build_mithril_signer_registration_follower(
148        &mut self,
149    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
150        let registerer = MithrilSignerRegistrationFollower::new(
151            self.get_epoch_service().await?,
152            self.get_verification_key_store().await?,
153            self.get_signer_store().await?,
154            self.get_signer_registration_verifier().await?,
155            self.get_leader_aggregator_client().await?,
156            self.get_stake_store().await?,
157        );
158
159        Ok(Arc::new(registerer))
160    }
161
162    /// Return a [MithrilSignerRegistrationFollower]
163    pub async fn get_mithril_signer_registration_follower(
164        &mut self,
165    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
166        get_dependency!(self.mithril_signer_registration_follower)
167    }
168
169    /// Return a [SignerRegisterer]
170    pub async fn get_signer_registerer(&mut self) -> Result<Arc<dyn SignerRegisterer>> {
171        get_dependency!(self.signer_registerer = get_mithril_signer_registration!(self))
172    }
173
174    /// Return a [SignerSynchronizer]
175    pub async fn get_signer_synchronizer(&mut self) -> Result<Arc<dyn SignerSynchronizer>> {
176        get_dependency!(self.signer_synchronizer = get_mithril_signer_registration!(self))
177    }
178
179    async fn build_signer_registration_verifier(
180        &mut self,
181    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
182        let registerer = MithrilSignerRegistrationVerifier::new(self.get_chain_observer().await?);
183
184        Ok(Arc::new(registerer))
185    }
186
187    /// Return a [SignerRegistrationVerifier]
188    pub async fn get_signer_registration_verifier(
189        &mut self,
190    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
191        get_dependency!(self.signer_registration_verifier)
192    }
193
194    /// Return a [SignerRegistrationRoundOpener]
195    pub async fn get_signer_registration_round_opener(
196        &mut self,
197    ) -> Result<Arc<dyn SignerRegistrationRoundOpener>> {
198        get_dependency!(
199            self.signer_registration_round_opener = get_mithril_signer_registration!(self)
200        )
201    }
202
203    async fn build_single_signature_authenticator(
204        &mut self,
205    ) -> Result<Arc<SingleSignatureAuthenticator>> {
206        let authenticator =
207            SingleSignatureAuthenticator::new(self.get_multi_signer().await?, self.root_logger());
208
209        Ok(Arc::new(authenticator))
210    }
211
212    /// [SingleSignatureAuthenticator] service
213    pub async fn get_single_signature_authenticator(
214        &mut self,
215    ) -> Result<Arc<SingleSignatureAuthenticator>> {
216        get_dependency!(self.single_signature_authenticator)
217    }
218}
mithril_aggregator/dependency_injection/builder/protocol/certificates.rs

mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs
