Add cardano_transactions_signing_config to Aggregator configuration

And pass them where needed to deduce a signed entity type from a time
point.

Also define a default configuration with:
* `security_parameter`: 3000
* `step`: 90

End to end use more lax paramters (security param: 20, step: 15) since
it's far faster and the last transactions we see included have a block
number not that high (arround ~450).

Author: Alenar

mithril-aggregator/src/configuration.rs

@@ -5,13 +5,13 @@ use mithril_common::crypto_helper::ProtocolGenesisSigner;
 use mithril_common::era::adapters::EraReaderAdapterType;
 use mithril_doc::{Documenter, DocumenterDefault, StructDoc};
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, HashMap};
 use std::path::PathBuf;
 use std::str::FromStr;
 
 use mithril_common::entities::{
-    CompressionAlgorithm, HexEncodedGenesisVerificationKey, ProtocolParameters, SignedEntityType,
-    SignedEntityTypeDiscriminants, TimePoint,
+    CardanoTransactionsSigningConfig, CompressionAlgorithm, HexEncodedGenesisVerificationKey,
+    ProtocolParameters, SignedEntityType, SignedEntityTypeDiscriminants, TimePoint,
 };
 use mithril_common::{CardanoNetwork, StdResult};
 
@@ -156,6 +156,10 @@ pub struct Configuration {
 
     /// Cardano transactions prover cache pool size
     pub cardano_transactions_prover_cache_pool_size: usize,
+
+    /// Cardano transactions signing configuration
+    #[example = "`{ security_parameter: 3000, step: 90 }`"]
+    pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
 }
 
 /// Uploader needed to copy the snapshot once computed.
@@ -229,6 +233,10 @@ impl Configuration {
             signer_importer_run_interval: 1,
             allow_unparsable_block: false,
             cardano_transactions_prover_cache_pool_size: 3,
+            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+                security_parameter: 100,
+                step: 15,
+            },
         }
     }
 
@@ -305,13 +313,19 @@ impl Configuration {
         let signed_entity_types = allowed_discriminants
             .into_iter()
             .map(|discriminant| {
-                SignedEntityType::from_time_point(&discriminant, &self.network, time_point)
+                SignedEntityType::from_time_point(
+                    &discriminant,
+                    &self.network,
+                    time_point,
+                    &self.cardano_transactions_signing_config,
+                )
             })
             .collect();
 
         Ok(signed_entity_types)
     }
 }
+
 /// Default configuration with all the default values for configurations.
 #[derive(Debug, Clone, DocumenterDefault)]
 pub struct DefaultConfiguration {
@@ -365,6 +379,9 @@ pub struct DefaultConfiguration {
 
     /// Cardano transactions prover cache pool size
     pub cardano_transactions_prover_cache_pool_size: u32,
+
+    /// Cardano transactions signing configuration
+    pub cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
 }
 
 impl Default for DefaultConfiguration {
@@ -386,6 +403,10 @@ impl Default for DefaultConfiguration {
             signer_importer_run_interval: 720,
             allow_unparsable_block: "false".to_string(),
             cardano_transactions_prover_cache_pool_size: 10,
+            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+                security_parameter: 3000,
+                step: 90,
+            },
         }
     }
 }
@@ -464,6 +485,23 @@ impl Source for DefaultConfiguration {
             "cardano_transactions_prover_cache_pool_size".to_string(),
             into_value(myself.cardano_transactions_prover_cache_pool_size),
         );
+        result.insert(
+            "cardano_transactions_signing_config".to_string(),
+            into_value(HashMap::from([
+                (
+                    "security_parameter".to_string(),
+                    ValueKind::from(
+                        myself
+                            .cardano_transactions_signing_config
+                            .security_parameter,
+                    ),
+                ),
+                (
+                    "step".to_string(),
+                    ValueKind::from(myself.cardano_transactions_signing_config.step),
+                ),
+            ])),
+        );
 
         Ok(result)
     }
@@ -623,7 +661,10 @@ mod test {
     #[test]
     fn test_list_allowed_signed_entity_types_with_specific_configuration() {
         let beacon = fake_data::beacon();
-        let chain_point = ChainPoint::dummy();
+        let chain_point = ChainPoint {
+            block_number: 45,
+            ..ChainPoint::dummy()
+        };
         let time_point = TimePoint::new(
             *beacon.epoch,
             beacon.immutable_file_number,
@@ -633,6 +674,10 @@ mod test {
         let config = Configuration {
             network: beacon.network.clone(),
             signed_entity_types: Some("CardanoStakeDistribution, CardanoTransactions".to_string()),
+            cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+                security_parameter: 0,
+                step: 15,
+            },
             ..Configuration::new_sample()
         };
 
@@ -650,4 +695,20 @@ mod test {
             signed_entity_types
         );
     }
+
+    #[test]
+    fn can_build_config_with_ctx_signing_config_from_default_configuration() {
+        #[derive(Debug, Deserialize)]
+        struct TargetConfig {
+            cardano_transactions_signing_config: CardanoTransactionsSigningConfig,
+        }
+
+        let config_builder = config::Config::builder().add_source(DefaultConfiguration::default());
+        let target: TargetConfig = config_builder.build().unwrap().try_deserialize().unwrap();
+
+        assert_eq!(
+            target.cardano_transactions_signing_config,
+            DefaultConfiguration::default().cardano_transactions_signing_config
+        );
+    }
 }

mithril-aggregator/src/dependency_injection/builder.rs

@@ -1219,6 +1219,9 @@ impl DependenciesBuilder {
             self.configuration.get_network().with_context(|| {
                 "Dependencies Builder can not get Cardano network while creating aggregator runner"
             })?,
+            self.configuration
+                .cardano_transactions_signing_config
+                .clone(),
         );
         let runtime = AggregatorRuntime::new(
             config,

mithril-aggregator/src/runtime/runner.rs

@@ -5,8 +5,8 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use mithril_common::entities::{
-    Certificate, CertificatePending, Epoch, ProtocolMessage, ProtocolMessagePartKey,
-    SignedEntityType, Signer, TimePoint,
+    CardanoTransactionsSigningConfig, Certificate, CertificatePending, Epoch, ProtocolMessage,
+    ProtocolMessagePartKey, SignedEntityType, Signer, TimePoint,
 };
 use mithril_common::{CardanoNetwork, StdResult};
 use mithril_persistence::store::StakeStorer;
@@ -25,12 +25,23 @@ pub struct AggregatorConfig {
 
     /// Cardano network
     pub network: CardanoNetwork,
+
+    /// Cardano transaction signing configuration
+    pub cardano_transaction_signing_config: CardanoTransactionsSigningConfig,
 }
 
 impl AggregatorConfig {
     /// Create a new instance of AggregatorConfig.
-    pub fn new(interval: Duration, network: CardanoNetwork) -> Self {
-        Self { interval, network }
+    pub fn new(
+        interval: Duration,
+        network: CardanoNetwork,
+        cardano_transaction_signing_config: CardanoTransactionsSigningConfig,
+    ) -> Self {
+        Self {
+            interval,
+            network,
+            cardano_transaction_signing_config,
+        }
     }
 }
 

mithril-aggregator/src/runtime/state_machine.rs

@@ -238,6 +238,7 @@ impl AggregatorRuntime {
                         &state.open_message.signed_entity_type.clone().into(),
                         &self.config.network.to_string(),
                         &last_time_point,
+                        &self.config.cardano_transaction_signing_config,
                     );
                     new_signed_entity_type != state.open_message.signed_entity_type
                 };
@@ -406,7 +407,7 @@ mod tests {
     use mockall::predicate;
     use std::time::Duration;
 
-    use mithril_common::entities::{Epoch, SignedEntityType};
+    use mithril_common::entities::{CardanoTransactionsSigningConfig, Epoch, SignedEntityType};
     use mithril_common::test_utils::fake_data;
 
     use super::super::runner::MockAggregatorRunner;
@@ -417,7 +418,11 @@ mod tests {
         runner: MockAggregatorRunner,
     ) -> AggregatorRuntime {
         AggregatorRuntime::new(
-            AggregatorConfig::new(Duration::from_millis(20), fake_data::network()),
+            AggregatorConfig::new(
+                Duration::from_millis(20),
+                fake_data::network(),
+                CardanoTransactionsSigningConfig::dummy(),
+            ),
             init_state,
             Arc::new(runner),
         )

mithril-aggregator/src/tools/certificates_hash_migrator.rs

@@ -191,8 +191,8 @@ impl CertificatesHashMigrator {
 #[cfg(test)]
 mod test {
     use mithril_common::entities::{
-        ChainPoint, ImmutableFileNumber, SignedEntityType, SignedEntityTypeDiscriminants as Type,
-        TimePoint,
+        CardanoTransactionsSigningConfig, ChainPoint, ImmutableFileNumber, SignedEntityType,
+        SignedEntityTypeDiscriminants as Type, TimePoint,
     };
     use mithril_common::test_utils::fake_data;
     use mithril_persistence::sqlite::{ConnectionBuilder, ConnectionOptions, SqliteConnection};
@@ -249,6 +249,7 @@ mod test {
                 &signed_entity_type,
                 &fake_data::network().to_string(),
                 &time_point,
+                &CardanoTransactionsSigningConfig::dummy(),
             ),
         );
 

mithril-aggregator/tests/test_extensions/aggregator_observer.rs

@@ -5,7 +5,10 @@ use mithril_aggregator::{
     services::{CertifierService, TickerService},
 };
 use mithril_common::{
-    entities::{Epoch, SignedEntityType, SignedEntityTypeDiscriminants, TimePoint},
+    entities::{
+        CardanoTransactionsSigningConfig, Epoch, SignedEntityType, SignedEntityTypeDiscriminants,
+        TimePoint,
+    },
     CardanoNetwork, StdResult, TimePointProvider,
 };
 use std::sync::Arc;
@@ -16,6 +19,7 @@ pub struct AggregatorObserver {
     time_point_provider: Arc<dyn TimePointProvider>,
     certifier_service: Arc<dyn CertifierService>,
     ticker_service: Arc<dyn TickerService>,
+    cardano_transaction_signing_config: CardanoTransactionsSigningConfig,
 }
 
 impl AggregatorObserver {
@@ -26,6 +30,10 @@ impl AggregatorObserver {
             time_point_provider: deps_builder.get_time_point_provider().await.unwrap(),
             certifier_service: deps_builder.get_certifier_service().await.unwrap(),
             ticker_service: deps_builder.get_ticker_service().await.unwrap(),
+            cardano_transaction_signing_config: deps_builder
+                .configuration
+                .cardano_transactions_signing_config
+                .clone(),
         }
     }
 
@@ -82,6 +90,7 @@ impl AggregatorObserver {
             &discriminant,
             &self.network.to_string(),
             &time_point,
+            &self.cardano_transaction_signing_config,
         ))
     }
 }

mithril-test-lab/mithril-end-to-end/src/mithril/aggregator.rs

@@ -86,6 +86,11 @@ impl Aggregator {
             ),
             ("CHAIN_OBSERVER_TYPE", aggregator_config.chain_observer_type),
             ("CARDANO_TRANSACTIONS_PROVER_CACHE_POOL_SIZE", "5"),
+            (
+                "CARDANO_TRANSACTIONS_SIGNING_CONFIG__SECURITY_PARAMETER",
+                "20",
+            ),
+            ("CARDANO_TRANSACTIONS_SIGNING_CONFIG__STEP", "15"),
         ]);
         let args = vec![
             "--db-directory",