testing era crashes on signer startup

Author: ghubertpalo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.2.25"
+version = "0.2.26"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/Cargo.toml

@@ -623,7 +623,7 @@ impl AggregatorRunnerTrait for AggregatorRunner {
             .collect::<Vec<_>>();
         let multi_signature = multisigner.get_multi_signature().await?.ok_or_else(|| {
             RunnerError::NoComputedMultiSignature(format!(
-                "No AVK returned by the multisigner for working certificate at beacon {:?}",
+                "no multi signature generated for beacon {:?}",
                 working_certificate.beacon
             ))
         })?;

mithril-aggregator/src/runtime/runner.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.2.20"
+version = "0.2.21"
 authors = { workspace = true }
 edition = { workspace = true }
 documentation = { workspace = true }

mithril-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-signer"
-version = "0.2.17"
+version = "0.2.18"
 description = "A Mithril Signer"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-signer/Cargo.toml

@@ -435,6 +435,8 @@ impl Runner for SignerRunner {
         &self,
         epoch: Epoch,
     ) -> Result<(), Box<dyn StdError + Sync + Send>> {
+        debug!("RUNNER: update_era_checker");
+
         let era_token = self
             .services
             .era_reader

mithril-signer/src/runtime/runner.rs

@@ -177,14 +177,17 @@ impl StateMachine {
                         "pending_certificate" => ?pending_certificate
                     );
 
-                    if self.runner.can_i_sign(&pending_certificate).await.map_err(|e| {
-                        RuntimeError::KeepState {
+                    if self
+                        .runner
+                        .can_i_sign(&pending_certificate)
+                        .await
+                        .map_err(|e| RuntimeError::KeepState {
                             message: format!(
-                                "could not determin if I can sign pending certificate at beacon {beacon:?}"
+                                "could not determine if I can sign certificate at beacon {beacon:?}"
                             ),
                             nested_error: Some(e),
-                        }
-                    })? {
+                        })?
+                    {
                         info!(" → we can sign this certificate, transiting to SIGNED");
                         self.state = self
                             .transition_from_registered_to_signed(&pending_certificate)
@@ -257,8 +260,8 @@ impl StateMachine {
     }
 
     async fn transition_from_init_to_unregistered(&self) -> Result<SignerState, RuntimeError> {
-        let current_beacon = self
-            .get_current_beacon("unregistered → unregistered")
+        let current_beacon = self.get_current_beacon("init → unregistered").await?;
+        self.update_era_checker(current_beacon.epoch, "init → unregistered")
             .await?;
 
         Ok(SignerState::Unregistered {
@@ -282,7 +285,7 @@ impl StateMachine {
         &self,
         beacon: Beacon,
     ) -> Result<SignerState, RuntimeError> {
-        self.update_era_checker(beacon.epoch, "unregistered → registered")
+        self.update_era_checker(beacon.epoch, "registered → unregistered")
             .await?;
 
         Ok(SignerState::Unregistered {

mithril-signer/src/runtime/state_machine.rs

@@ -0,0 +1,52 @@
+mod test_extensions;
+
+use mithril_common::{
+    crypto_helper::tests_setup,
+    entities::Epoch,
+    era::{EraMarker, SupportedEra},
+    test_utils::MithrilFixtureBuilder,
+};
+
+use test_extensions::StateMachineTester;
+
+#[rustfmt::skip]
+#[tokio::test]
+async fn era_fail_at_startup() {
+    let protocol_parameters = tests_setup::setup_protocol_parameters();
+    let fixture = MithrilFixtureBuilder::default().with_signers(10).with_protocol_parameters(protocol_parameters.into()).build();
+    let signers_with_stake = fixture.signers_with_stake();
+    let mut tester = StateMachineTester::init(&signers_with_stake)
+        .await.expect("state machine tester init should not fail");
+    tester.set_era_markers(vec![EraMarker::new("whatever", Some(Epoch(0)))]);
+
+    tester
+        .comment("TEST: state machine fails starting when current Era is not supported.")
+        .is_init().unwrap()
+        .cycle_unregistered().await
+        .expect_err("The state machine must fail at startup.");
+
+    tester
+        .comment("TEST: state machine fails when transiting to a new unsupported Era.")
+        .set_era_markers(vec![
+            EraMarker::new(&SupportedEra::dummy().to_string(), Some(Epoch(0))),
+            EraMarker::new("unsupported", Some(Epoch(4))),
+            ])
+        .is_init().unwrap()
+        .cycle_unregistered().await.unwrap()
+        .check_era_checker_last_updated_at(Epoch(1)).await.unwrap()
+        .comment("Init Era checking went well, now let's go to usual business…")
+        .increase_epoch(2).await.unwrap()
+        .cycle_unregistered().await.unwrap()
+        .check_era_checker_last_updated_at(Epoch(2)).await.unwrap()
+        .aggregator_send_epoch_settings().await
+        .cycle_registered().await.unwrap()
+        .increase_epoch(3).await.unwrap()
+        .cycle_unregistered().await.unwrap()
+        .check_era_checker_last_updated_at(Epoch(3)).await.unwrap()
+        .aggregator_send_epoch_settings().await
+        .cycle_registered().await.unwrap()
+        .increase_epoch(4).await.unwrap()
+        .comment("Reaching unsupported Era Epoch")
+        .cycle_unregistered().await
+        .expect_err("The state machine must fail because of unsupported Era.");
+}

mithril-signer/tests/era_switch.rs

@@ -1,13 +1,16 @@
+#![allow(dead_code)]
 use mithril_common::digesters::ImmutableFileObserver;
 use mithril_common::entities::SignerWithStake;
 use mithril_common::era::{
-    adapters::{EraReaderAdapterType, EraReaderBootstrapAdapter},
+    adapters::{EraReaderAdapterType, EraReaderDummyAdapter},
     EraChecker, EraReader,
 };
+use mithril_common::era::{EraMarker, SupportedEra};
 use mithril_common::BeaconProvider;
 use slog::Drain;
 use slog_scope::debug;
 use std::error::Error as StdError;
+use std::fmt::Debug;
 use std::{path::PathBuf, sync::Arc, time::Duration};
 use thiserror::Error;
 
@@ -53,10 +56,18 @@ pub struct StateMachineTester {
     protocol_initializer_store: Arc<ProtocolInitializerStore>,
     stake_store: Arc<StakeStore>,
     era_checker: Arc<EraChecker>,
+    era_reader_adapter: Arc<EraReaderDummyAdapter>,
     comment_no: u32,
     _logs_guard: slog_scope::GlobalLoggerGuard,
 }
 
+impl Debug for StateMachineTester {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        debug!("Debug called after comment N°{}.", self.comment_no);
+        write!(f, "DEBUG")
+    }
+}
+
 impl StateMachineTester {
     pub async fn init(signers_with_stake: &[SignerWithStake]) -> Result<Self> {
         let selected_signer_with_stake = signers_with_stake.first().ok_or_else(|| {
@@ -119,7 +130,13 @@ impl StateMachineTester {
             Box::new(MemoryAdapter::new(None).unwrap()),
             config.store_retention_limit,
         ));
-        let era_reader = Arc::new(EraReader::new(Arc::new(EraReaderBootstrapAdapter)));
+        let era_reader_adapter = Arc::new(EraReaderDummyAdapter::from_markers(vec![
+            (EraMarker {
+                name: SupportedEra::dummy().to_string(),
+                epoch: Some(Epoch(0)),
+            }),
+        ]));
+        let era_reader = Arc::new(EraReader::new(era_reader_adapter.clone()));
         let era_epoch_token = era_reader
             .read_era_epoch_token(beacon_provider.get_current_beacon().await.unwrap().epoch)
             .await
@@ -157,6 +174,7 @@ impl StateMachineTester {
             protocol_initializer_store,
             stake_store,
             era_checker,
+            era_reader_adapter,
             comment_no: 0,
             _logs_guard: logs_guard,
         })
@@ -324,4 +342,12 @@ impl StateMachineTester {
             format!("The epoch the EraChecker has been the last updated '{}' is different from expected epoch '{}'.", self.era_checker.current_epoch(), epoch)
         )
     }
+
+    /// Set Era markers
+    pub fn set_era_markers(&mut self, markers: Vec<EraMarker>) -> &mut Self {
+        debug!("Era markers set: {:?}", markers);
+        self.era_reader_adapter.set_markers(markers);
+
+        self
+    }
 }