Struct DependenciesBuilder 

pub struct DependenciesBuilder {

    pub configuration: Arc<dyn ConfigurationSource>,
    pub root_logger: Logger,
    pub sqlite_connection: Option<Arc<SqliteConnection>>,
    pub sqlite_connection_event_store: Option<Arc<SqliteConnection>>,
    pub sqlite_connection_cardano_transaction_pool: Option<Arc<SqliteConnectionPool>>,
    pub stake_store: Option<Arc<StakePoolStore>>,
    pub snapshot_uploader: Option<Arc<dyn FileUploader>>,
    pub multi_signer: Option<Arc<dyn MultiSigner>>,
    pub certificate_repository: Option<Arc<CertificateRepository>>,
    pub open_message_repository: Option<Arc<OpenMessageRepository>>,
    pub verification_key_store: Option<Arc<dyn VerificationKeyStorer>>,
    pub epoch_settings_store: Option<Arc<EpochSettingsStore>>,
    pub cardano_cli_runner: Option<Box<CardanoCliRunner>>,
    pub chain_observer: Option<Arc<dyn ChainObserver>>,
    pub chain_block_reader: Option<Arc<Mutex<dyn ChainBlockReader>>>,
    pub transaction_repository: Option<Arc<CardanoTransactionRepository>>,
    pub block_scanner: Option<Arc<dyn BlockScanner>>,
    pub immutable_digester: Option<Arc<dyn ImmutableDigester>>,
    pub immutable_file_observer: Option<Arc<dyn ImmutableFileObserver>>,
    pub immutable_cache_provider: Option<Arc<dyn ImmutableFileDigestCacheProvider>>,
    pub immutable_file_digest_mapper: Option<Arc<dyn ImmutableFileDigestMapper>>,
    pub digester: Option<Arc<dyn ImmutableDigester>>,
    pub file_archiver: Option<Arc<FileArchiver>>,
    pub snapshotter: Option<Arc<dyn Snapshotter>>,
    pub certificate_verifier: Option<Arc<dyn CertificateVerifier>>,
    pub genesis_verifier: Option<Arc<ProtocolGenesisVerifier>>,
    pub certificate_chain_synchronizer: Option<Arc<dyn CertificateChainSynchronizer>>,
    pub mithril_signer_registration_leader: Option<Arc<MithrilSignerRegistrationLeader>>,
    pub mithril_signer_registration_follower: Option<Arc<MithrilSignerRegistrationFollower>>,
    pub signer_registerer: Option<Arc<dyn SignerRegisterer>>,
    pub signer_synchronizer: Option<Arc<dyn SignerSynchronizer>>,
    pub signer_registration_verifier: Option<Arc<dyn SignerRegistrationVerifier>>,
    pub signer_registration_round_opener: Option<Arc<dyn SignerRegistrationRoundOpener>>,
    pub era_checker: Option<Arc<EraChecker>>,
    pub era_reader_adapter: Option<Arc<dyn EraReaderAdapter>>,
    pub era_reader: Option<Arc<EraReader>>,
    pub event_transmitter: Option<Arc<TransmitterService<EventMessage>>>,
    pub event_transmitter_channel: (Option<UnboundedReceiver<EventMessage>>, Option<UnboundedSender<EventMessage>>),
    pub api_version_provider: Option<Arc<APIVersionProvider>>,
    pub stake_distribution_service: Option<Arc<dyn StakeDistributionService>>,
    pub ticker_service: Option<Arc<dyn TickerService>>,
    pub signer_store: Option<Arc<SignerStore>>,
    pub signable_seed_builder: Option<Arc<dyn SignableSeedBuilder>>,
    pub signable_builder_service: Option<Arc<dyn SignableBuilderService>>,
    pub signed_entity_service: Option<Arc<dyn SignedEntityService>>,
    pub certifier_service: Option<Arc<dyn CertifierService>>,
    pub epoch_service: Option<EpochServiceWrapper>,
    pub mithril_network_configuration_provider: Option<Arc<dyn MithrilNetworkConfigurationProvider>>,
    pub signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>,
    pub message_service: Option<Arc<dyn MessageService>>,
    pub prover_service: Option<Arc<dyn ProverService>>,
    pub signed_entity_type_lock: Option<Arc<SignedEntityTypeLock>>,
    pub transactions_importer: Option<Arc<dyn TransactionsImporter>>,
    pub upkeep_service: Option<Arc<dyn UpkeepService>>,
    pub single_signature_authenticator: Option<Arc<SingleSignatureAuthenticator>>,
    pub metrics_service: Option<Arc<MetricsService>>,
    pub leader_aggregator_client: Option<Arc<AggregatorHttpClient>>,
    pub protocol_parameters_retriever: Option<Arc<dyn ProtocolParametersRetriever>>,
    pub stop_signal_channel: Option<(Sender<()>, Receiver<()>)>,
}

Dependencies container builder

This is meant to create SHARED DEPENDENCIES, ie: dependencies instances that must be shared amongst several Tokio tasks. For example, database repositories are NOT shared dependencies and therefor can be created ad hoc whereas the database connection is a shared dependency.

Each shared dependency must implement a build and a get function. The build function creates the dependency, the get function creates the dependency at first call then return a clone of the Arc containing the dependency for all further calls.

Fields

configuration: Arc<dyn ConfigurationSource>

Configuration parameters

root_logger: Logger

Application root logger

sqlite_connection: Option<Arc<SqliteConnection>>

SQLite database connection

sqlite_connection_event_store: Option<Arc<SqliteConnection>>

Event store SQLite database connection

sqlite_connection_cardano_transaction_pool: Option<Arc<SqliteConnectionPool>>

Cardano transactions SQLite database connection pool

stake_store: Option<Arc<StakePoolStore>>

Stake Store used by the StakeDistributionService It shall be a private dependency.

snapshot_uploader: Option<Arc<dyn FileUploader>>

Snapshot uploader service.

multi_signer: Option<Arc<dyn MultiSigner>>

Multisigner service.

certificate_repository: Option<Arc<CertificateRepository>>

Certificate repository.

open_message_repository: Option<Arc<OpenMessageRepository>>

Open message repository.

verification_key_store: Option<Arc<dyn VerificationKeyStorer>>

Verification key store.

epoch_settings_store: Option<Arc<EpochSettingsStore>>

Epoch settings store.

cardano_cli_runner: Option<Box<CardanoCliRunner>>

Cardano CLI Runner for the [ChainObserver]

chain_observer: Option<Arc<dyn ChainObserver>>

Chain observer service.

chain_block_reader: Option<Arc<Mutex<dyn ChainBlockReader>>>

Chain block reader

transaction_repository: Option<Arc<CardanoTransactionRepository>>

Cardano transactions repository.

block_scanner: Option<Arc<dyn BlockScanner>>

Cardano block scanner.

immutable_digester: Option<Arc<dyn ImmutableDigester>>

Immutable file digester service.

immutable_file_observer: Option<Arc<dyn ImmutableFileObserver>>

Immutable file observer service.

immutable_cache_provider: Option<Arc<dyn ImmutableFileDigestCacheProvider>>

Immutable cache provider service.

immutable_file_digest_mapper: Option<Arc<dyn ImmutableFileDigestMapper>>

Immutable file digest mapper service.

digester: Option<Arc<dyn ImmutableDigester>>

Digester service.

file_archiver: Option<Arc<FileArchiver>>

File archiver service.

snapshotter: Option<Arc<dyn Snapshotter>>

Snapshotter service.

certificate_verifier: Option<Arc<dyn CertificateVerifier>>

Certificate verifier service.

genesis_verifier: Option<Arc<ProtocolGenesisVerifier>>

Genesis signature verifier service.

certificate_chain_synchronizer: Option<Arc<dyn CertificateChainSynchronizer>>

Certificate chain synchronizer service

mithril_signer_registration_leader: Option<Arc<MithrilSignerRegistrationLeader>>

Mithril signer registration leader service

mithril_signer_registration_follower: Option<Arc<MithrilSignerRegistrationFollower>>

Mithril signer registration follower service

signer_registerer: Option<Arc<dyn SignerRegisterer>>

Signer registerer service

signer_synchronizer: Option<Arc<dyn SignerSynchronizer>>

Signer synchronizer service

signer_registration_verifier: Option<Arc<dyn SignerRegistrationVerifier>>

Signer registration verifier

signer_registration_round_opener: Option<Arc<dyn SignerRegistrationRoundOpener>>

Signer registration round opener service

era_checker: Option<Arc<EraChecker>>

Era checker service

era_reader_adapter: Option<Arc<dyn EraReaderAdapter>>

Adapter for [EraReader]

era_reader: Option<Arc<EraReader>>

Era reader service

event_transmitter: Option<Arc<TransmitterService<EventMessage>>>

Event Transmitter Service

event_transmitter_channel: (Option<UnboundedReceiver<EventMessage>>, Option<UnboundedSender<EventMessage>>)

Event transmitter Channel Sender endpoint

api_version_provider: Option<Arc<APIVersionProvider>>

API Version provider

stake_distribution_service: Option<Arc<dyn StakeDistributionService>>

Stake Distribution Service

ticker_service: Option<Arc<dyn TickerService>>

Ticker Service

signer_store: Option<Arc<SignerStore>>

Signer Store

signable_seed_builder: Option<Arc<dyn SignableSeedBuilder>>

Signable Seed Builder

signable_builder_service: Option<Arc<dyn SignableBuilderService>>

Signable Builder Service

signed_entity_service: Option<Arc<dyn SignedEntityService>>

Signed Entity Service

certifier_service: Option<Arc<dyn CertifierService>>

Certifier service

epoch_service: Option<EpochServiceWrapper>

Epoch service.

mithril_network_configuration_provider: Option<Arc<dyn MithrilNetworkConfigurationProvider>>

Mithril network configuration provider

signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>

Signed Entity storer

message_service: Option<Arc<dyn MessageService>>

HTTP Message service

prover_service: Option<Arc<dyn ProverService>>

Prover service

signed_entity_type_lock: Option<Arc<SignedEntityTypeLock>>

Signed Entity Type Lock

transactions_importer: Option<Arc<dyn TransactionsImporter>>

Transactions Importer

upkeep_service: Option<Arc<dyn UpkeepService>>

Upkeep service

single_signature_authenticator: Option<Arc<SingleSignatureAuthenticator>>

Single signer authenticator

metrics_service: Option<Arc<MetricsService>>

Metrics service

leader_aggregator_client: Option<Arc<AggregatorHttpClient>>

Leader aggregator client

protocol_parameters_retriever: Option<Arc<dyn ProtocolParametersRetriever>>

Protocol parameters retriever

stop_signal_channel: Option<(Sender<()>, Receiver<()>)>

Stop signal channel

Implementations

impl DependenciesBuilder

pub async fn get_chain_observer(&mut self) -> Result<Arc<dyn ChainObserver>>

Return a [ChainObserver]

pub async fn get_cardano_cli_runner(&mut self) -> Result<Box<CardanoCliRunner>>

Return a [CardanoCliRunner]

pub async fn get_chain_block_reader( &mut self, ) -> Result<Arc<Mutex<dyn ChainBlockReader>>>

Chain reader

pub async fn get_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>>

Block scanner

pub async fn get_immutable_digester( &mut self, ) -> Result<Arc<dyn ImmutableDigester>>

Immutable digester.

pub async fn create_cardano_transactions_preloader( &mut self, ) -> Result<Arc<CardanoTransactionsPreloader>>

Create a CardanoTransactionsPreloader instance.

pub async fn get_stake_distribution_service( &mut self, ) -> Result<Arc<dyn StakeDistributionService>>

StakeDistributionService service

impl DependenciesBuilder

pub async fn get_epoch_service(&mut self) -> Result<EpochServiceWrapper>

EpochService service

pub async fn get_mithril_network_configuration_provider( &mut self, ) -> Result<Arc<dyn MithrilNetworkConfigurationProvider>>

[MithrilNetworkConfigurationProvider][mithril_protocol_config::interface::MithrilNetworkConfigurationProvider] service

impl DependenciesBuilder

pub async fn get_signed_entity_type_lock( &mut self, ) -> Result<Arc<SignedEntityTypeLock>>

Get the [SignedEntityTypeLock] instance

pub async fn build_message_service(&mut self) -> Result<Arc<dyn MessageService>>

Builds HTTP message service

pub async fn get_message_service(&mut self) -> Result<Arc<dyn MessageService>>

MessageService service

pub async fn build_leader_aggregator_client( &mut self, ) -> Result<Arc<AggregatorHttpClient>>

Builds an [AggregatorHttpClient]

pub async fn get_leader_aggregator_client( &mut self, ) -> Result<Arc<AggregatorHttpClient>>

Returns a leader [AggregatorHttpClient]

pub async fn build_signature_consumer( &mut self, ) -> Result<Arc<dyn SignatureConsumer>>

Builds a SignatureConsumer

pub async fn create_signature_processor( &mut self, ) -> Result<Arc<dyn SignatureProcessor>>

Builds a SignatureProcessor

impl DependenciesBuilder

pub async fn build_ticker_service(&mut self) -> Result<Arc<dyn TickerService>>

Create TickerService instance.

pub async fn get_ticker_service(&mut self) -> Result<Arc<dyn TickerService>>

TickerService service

pub async fn get_immutable_file_observer( &mut self, ) -> Result<Arc<dyn ImmutableFileObserver>>

Return a [ImmutableFileObserver] instance.

impl DependenciesBuilder

pub async fn get_signed_entity_service( &mut self, ) -> Result<Arc<dyn SignedEntityService>>

SignedEntityService service

pub async fn get_snapshotter(&mut self) -> Result<Arc<dyn Snapshotter>>

Snapshotter service.

pub async fn get_snapshot_uploader(&mut self) -> Result<Arc<dyn FileUploader>>

Get a FileUploader

impl DependenciesBuilder

pub async fn build_certifier_service( &mut self, ) -> Result<Arc<dyn CertifierService>>

Create CertifierService service

pub async fn get_certifier_service( &mut self, ) -> Result<Arc<dyn CertifierService>>

CertifierService service

pub async fn get_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>>

Get a configured multi signer

pub async fn get_certificate_chain_synchronizer( &mut self, ) -> Result<Arc<dyn CertificateChainSynchronizer>>

CertificateChainSynchronizer service

pub async fn get_certificate_verifier( &mut self, ) -> Result<Arc<dyn CertificateVerifier>>

CertificateVerifier service.

pub async fn get_genesis_verifier( &mut self, ) -> Result<Arc<ProtocolGenesisVerifier>>

Return a ProtocolGenesisVerifier

pub async fn get_mithril_signer_registration_leader( &mut self, ) -> Result<Arc<MithrilSignerRegistrationLeader>>

Return a MithrilSignerRegistrationLeader

pub async fn get_mithril_signer_registration_follower( &mut self, ) -> Result<Arc<MithrilSignerRegistrationFollower>>

Return a MithrilSignerRegistrationFollower

pub async fn get_signer_registerer( &mut self, ) -> Result<Arc<dyn SignerRegisterer>>

Return a SignerRegisterer

pub async fn get_signer_synchronizer( &mut self, ) -> Result<Arc<dyn SignerSynchronizer>>

Return a SignerSynchronizer

pub async fn get_signer_registration_verifier( &mut self, ) -> Result<Arc<dyn SignerRegistrationVerifier>>

Return a SignerRegistrationVerifier

pub async fn get_signer_registration_round_opener( &mut self, ) -> Result<Arc<dyn SignerRegistrationRoundOpener>>

Return a SignerRegistrationRoundOpener

pub async fn get_single_signature_authenticator( &mut self, ) -> Result<Arc<SingleSignatureAuthenticator>>

SingleSignatureAuthenticator service

impl DependenciesBuilder

pub async fn build_prover_service(&mut self) -> Result<Arc<dyn ProverService>>

Build Prover service

pub async fn get_prover_service(&mut self) -> Result<Arc<dyn ProverService>>

ProverService service

impl DependenciesBuilder

pub async fn get_signable_builder_service( &mut self, ) -> Result<Arc<dyn SignableBuilderService>>

SignableBuilderService service

pub async fn get_signable_seed_builder( &mut self, ) -> Result<Arc<dyn SignableSeedBuilder>>

SignableSeedBuilder service

pub async fn get_transactions_importer( &mut self, ) -> Result<Arc<dyn TransactionsImporter>>

Get the TransactionsImporter instance

impl DependenciesBuilder

pub async fn get_api_version_provider( &mut self, ) -> Result<Arc<APIVersionProvider>>

APIVersionProvider service

pub async fn get_era_reader(&mut self) -> Result<Arc<EraReader>>

[EraReader] service

pub async fn get_era_checker(&mut self) -> Result<Arc<EraChecker>>

[EraReader] service

impl DependenciesBuilder

pub fn root_logger(&self) -> Logger

Return a copy of the root logger.

pub async fn create_usage_reporter(&mut self) -> Result<UsageReporter>

Create a UsageReporter instance.

pub async fn get_metrics_service(&mut self) -> Result<Arc<MetricsService>>

MetricsService service

pub async fn create_event_store(&mut self) -> Result<EventStore>

Create dependencies for the EventStore task.

pub async fn get_event_transmitter_sender( &mut self, ) -> Result<UnboundedSender<EventMessage>>

Return the EventMessage channel sender.

pub async fn get_event_transmitter_receiver( &mut self, ) -> Result<UnboundedReceiver<EventMessage>>

Return the channel receiver setup for the EventStore. Since this receiver is not clonable, it must be called only once.

pub async fn get_event_transmitter( &mut self, ) -> Result<Arc<TransmitterService<EventMessage>>>

TransmitterService service

impl DependenciesBuilder

pub async fn build_stop_signal_channel( &mut self, ) -> Result<(Sender<()>, Receiver<()>)>

Builds a stop signal channel

pub async fn get_stop_signal_channel( &mut self, ) -> Result<(Sender<()>, Receiver<()>)>

Get the stop signal channel

impl DependenciesBuilder

pub async fn drop_sqlite_connections(&self)

Execute cleanup operations on SQLite connections

pub async fn get_sqlite_connection(&mut self) -> Result<Arc<SqliteConnection>>

Get SQLite connection

pub async fn get_event_store_sqlite_connection( &mut self, ) -> Result<Arc<SqliteConnection>>

Get EventStore SQLite connection

pub async fn get_sqlite_connection_cardano_transaction_pool( &mut self, ) -> Result<Arc<SqliteConnectionPool>>

Get SQLite connection pool for the cardano transactions store

impl DependenciesBuilder

pub async fn get_stake_store(&mut self) -> Result<Arc<StakePoolStore>>

Return a StakePoolStore

pub async fn get_certificate_repository( &mut self, ) -> Result<Arc<CertificateRepository>>

Get a configured CertificateRepository.

pub async fn get_open_message_repository( &mut self, ) -> Result<Arc<OpenMessageRepository>>

Get a configured OpenMessageRepository.

pub async fn get_verification_key_store( &mut self, ) -> Result<Arc<dyn VerificationKeyStorer>>

Get a configured VerificationKeyStorer.

pub async fn get_protocol_parameters_retriever( &mut self, ) -> Result<Arc<dyn ProtocolParametersRetriever>>

Get a configured ProtocolParametersRetriever.

pub async fn get_epoch_settings_store( &mut self, ) -> Result<Arc<EpochSettingsStore>>

Get a configured EpochSettingsStore.

pub async fn get_immutable_cache_provider( &mut self, ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>>

Get an [ImmutableFileDigestCacheProvider]

pub async fn get_transaction_repository( &mut self, ) -> Result<Arc<CardanoTransactionRepository>>

Transaction repository.

pub async fn get_immutable_file_digest_mapper( &mut self, ) -> Result<Arc<dyn ImmutableFileDigestMapper>>

Immutable digest mapper.

pub async fn get_signer_store(&mut self) -> Result<Arc<SignerStore>>

SignerStore service

pub async fn get_signed_entity_storer( &mut self, ) -> Result<Arc<dyn SignedEntityStorer>>

SignedEntityStorer service

pub async fn create_signer_importer( &mut self, cexplorer_pools_url: &str, ) -> Result<SignersImporter>

Create a SignersImporter instance.

impl DependenciesBuilder

pub async fn get_signer_registration_pruning_task( &mut self, ) -> Result<Arc<dyn EpochPruningTask>>

Return a EpochPruningTask instance

pub async fn get_upkeep_service(&mut self) -> Result<Arc<dyn UpkeepService>>

Get the UpkeepService instance

impl DependenciesBuilder

pub fn new( root_logger: Logger, configuration: Arc<dyn ConfigurationSource>, ) -> Self

Create a new clean dependency builder

pub async fn build_serve_dependencies_container( &mut self, ) -> Result<ServeCommandDependenciesContainer>

Return an unconfigured ServeCommandDependenciesContainer

pub async fn create_aggregator_runner(&mut self) -> Result<AggregatorRuntime>

Create the AggregatorRunner

pub async fn create_http_routes( &mut self, ) -> Result<impl Filter<Extract = (impl Reply + use<>,), Error = Rejection> + Clone + use<>>

Create the HTTP route instance

pub async fn create_genesis_container( &mut self, ) -> Result<GenesisCommandDependenciesContainer>

Create dependencies for genesis commands

pub async fn create_database_command_container( &mut self, ) -> Result<DatabaseCommandDependenciesContainer>

Create dependencies for database command

pub async fn create_tools_command_container( &mut self, ) -> Result<ToolsCommandDependenciesContainer>

Create dependencies for tools command

pub async fn handle_discrepancies_at_startup(&mut self) -> Result<()>

Look for discrepancies in stored data and fix them.

Fix discrepancies for:

• epoch settings: ensure that the network configuration parameters for the three working epochs window are stored in the database (see [mithril_protocol_config::model::MithrilNetworkConfiguration])

pub async fn vanish(self)

Remove the dependencies builder from memory to release Arc instances.