Feat(e2e): support multiple aggregators in the e2e tests

.github/workflows/ci.yml

@@ -303,14 +303,22 @@ jobs:
         extra_args: [""]
 
         include:
-          # Include a test for the P2P mode
-          - mode: "p2p"
+          # Include a test for partial decentralization with master/slave signer registration and P2P signature registration
+          - mode: "master-slave"
             era: ${{ fromJSON(needs.build-ubuntu-X64.outputs.eras)[0] }}
             next_era: [""]
             cardano_node_version: "10.2.1"
             hard_fork_latest_era_at_epoch: 0
             run_id: "#1"
-            extra_args: "--use-p2p-network"
+            extra_args: "--number-of-aggregators=2 --use-relays --relay-signer-registration-mode=passthrough --relay-signature-registration-mode=p2p"
+          # Include a test for full dedentralization P2P signer registration and P2P signature registration
+          - mode: "decentralized"
+            era: ${{ fromJSON(needs.build-ubuntu-X64.outputs.eras)[0] }}
+            next_era: ""
+            cardano_node_version: "10.1.4"
+            hard_fork_latest_era_at_epoch: 0
+            run_id: "#1"
+            extra_args: "--number-of-aggregators=2 --use-relays --relay-signer-registration-mode=p2p --relay-signature-registration-mode=p2p"
           # Include a test for the era switch without regenesis
           - mode: "std"
             era: ${{ fromJSON(needs.build-ubuntu-X64.outputs.eras)[0] }}

mithril-aggregator/Cargo.toml

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

mithril-aggregator/src/dependency_injection/builder/protocol/certificates.rs

@@ -161,6 +161,7 @@ impl DependenciesBuilder {
         &mut self,
     ) -> Result<Arc<MithrilSignerRegistrationSlave>> {
         let registerer = MithrilSignerRegistrationSlave::new(
+            self.get_epoch_service().await?,
             self.get_verification_key_store().await?,
             self.get_signer_store().await?,
             self.get_signer_registration_verifier().await?,

mithril-aggregator/src/runtime/state_machine.rs

@@ -143,7 +143,6 @@ impl AggregatorRuntime {
                 info!(self.logger, "→ Trying to transition to READY"; "last_time_point" => ?last_time_point);
 
                 let can_try_transition_from_idle_to_ready = if self.config.is_slave {
-                    println!("Checking if slave aggregator is at the same epoch as master");
                     self.runner
                         .is_slave_aggregator_at_same_epoch_as_master(&last_time_point)
                         .await?
@@ -265,18 +264,17 @@ impl AggregatorRuntime {
             self.runner
                 .update_stake_distribution(&new_time_point)
                 .await?;
-            if self.config.is_slave {
-                self.runner
-                    .synchronize_slave_aggregator_signer_registration()
-                    .await?;
-            }
             self.runner.inform_new_epoch(new_time_point.epoch).await?;
-
             self.runner.upkeep(new_time_point.epoch).await?;
             self.runner
                 .open_signer_registration_round(&new_time_point)
                 .await?;
             self.runner.update_epoch_settings().await?;
+            if self.config.is_slave {
+                self.runner
+                    .synchronize_slave_aggregator_signer_registration()
+                    .await?;
+            }
             self.runner.precompute_epoch_data().await?;
         }
 

mithril-aggregator/src/services/epoch_service.rs

@@ -49,6 +49,9 @@ pub trait EpochService: Sync + Send {
     /// Note: must be called after `inform_epoch`.
     async fn update_epoch_settings(&mut self) -> StdResult<()>;
 
+    /// Update the next signers with stake for the next epoch.
+    async fn update_next_signers_with_stake(&mut self) -> StdResult<()>;
+
     /// Inform the service that it can precompute data for its current epoch.
     ///
     /// Note: must be called after `inform_epoch`.
@@ -383,6 +386,27 @@ impl EpochService for MithrilEpochService {
         self.insert_future_epoch_settings(data.epoch).await
     }
 
+    async fn update_next_signers_with_stake(&mut self) -> StdResult<()> {
+        debug!(self.logger, ">> update_next_signers_with_stake");
+
+        let data = self.unwrap_data().with_context(|| {
+            "can't update next signers with stake if inform_epoch has not been called first"
+        })?;
+
+        let next_signer_retrieval_epoch = data.epoch.offset_to_next_signer_retrieval_epoch();
+        let next_signers_with_stake = self
+            .get_signers_with_stake_at_epoch(next_signer_retrieval_epoch)
+            .await?;
+
+        self.epoch_data.as_mut().unwrap().next_signers_with_stake = next_signers_with_stake;
+
+        self.precompute_epoch_data()
+            .await
+            .with_context(|| "Epoch service failed to precompute epoch data")?;
+
+        Ok(())
+    }
+
     async fn precompute_epoch_data(&mut self) -> StdResult<()> {
         debug!(self.logger, ">> precompute_epoch_data");
 
@@ -523,6 +547,7 @@ pub(crate) struct FakeEpochService {
     inform_epoch_error: bool,
     update_epoch_settings_error: bool,
     precompute_epoch_data_error: bool,
+    update_next_signers_with_stake_error: bool,
 }
 
 #[cfg(test)]
@@ -615,6 +640,7 @@ impl FakeEpochServiceBuilder {
             inform_epoch_error: false,
             update_epoch_settings_error: false,
             precompute_epoch_data_error: false,
+            update_next_signers_with_stake_error: false,
         }
     }
 }
@@ -660,19 +686,21 @@ impl FakeEpochService {
             inform_epoch_error: false,
             update_epoch_settings_error: false,
             precompute_epoch_data_error: false,
+            update_next_signers_with_stake_error: false,
         }
     }
 
-    #[allow(dead_code)]
     pub fn toggle_errors(
         &mut self,
         inform_epoch: bool,
         update_protocol_parameters: bool,
         precompute_epoch: bool,
+        update_next_signers_with_stake: bool,
     ) {
         self.inform_epoch_error = inform_epoch;
         self.update_epoch_settings_error = update_protocol_parameters;
         self.precompute_epoch_data_error = precompute_epoch;
+        self.update_next_signers_with_stake_error = update_next_signers_with_stake;
     }
 
     fn unwrap_data(&self) -> Result<&EpochData, EpochServiceError> {
@@ -714,6 +742,13 @@ impl EpochService for FakeEpochService {
         Ok(())
     }
 
+    async fn update_next_signers_with_stake(&mut self) -> StdResult<()> {
+        if self.update_next_signers_with_stake_error {
+            anyhow::bail!("update_next_signers_with_stake fake error");
+        }
+        Ok(())
+    }
+
     fn cardano_era(&self) -> StdResult<CardanoEra> {
         Ok(self.unwrap_data()?.cardano_era.clone())
     }
@@ -1213,6 +1248,48 @@ mod tests {
         assert!(service.computed_epoch_data.is_none());
     }
 
+    #[tokio::test]
+    async fn update_next_signers_with_stake_succeeds() {
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let next_fixture = MithrilFixtureBuilder::default().with_signers(5).build();
+        let next_avk = next_fixture.compute_avk();
+        let epoch = Epoch(4);
+        let mut service = EpochServiceBuilder {
+            next_signers_with_stake: next_fixture.signers_with_stake().clone(),
+            ..EpochServiceBuilder::new(epoch, fixture.clone())
+        }
+        .build()
+        .await;
+        service
+            .inform_epoch(epoch)
+            .await
+            .expect("inform_epoch should not fail");
+        service.epoch_data = Some(EpochData {
+            next_signers_with_stake: vec![],
+            ..service.epoch_data.unwrap()
+        });
+        service.computed_epoch_data = None;
+
+        service
+            .update_next_signers_with_stake()
+            .await
+            .expect("update_next_signers_with_stake should not fail");
+
+        let expected_next_signers_with_stake = next_fixture.signers_with_stake();
+        assert_eq!(
+            expected_next_signers_with_stake,
+            service.epoch_data.unwrap().next_signers_with_stake
+        );
+
+        assert_eq!(
+            next_avk,
+            service
+                .computed_epoch_data
+                .unwrap()
+                .next_aggregate_verification_key
+        );
+    }
+
     #[tokio::test]
     async fn update_epoch_settings_insert_future_epoch_settings_in_the_store() {
         let future_protocol_parameters = ProtocolParameters::new(6, 89, 0.124);

mithril-aggregator/src/services/signer_registration/error.rs

@@ -31,9 +31,13 @@ pub enum SignerRegistrationError {
     #[error("signer already registered")]
     ExistingSigner(Box<SignerWithStake>),
 
-    /// Store error.
+    /// Store.
     #[error("store error")]
-    StoreError(#[source] StdError),
+    Store(#[source] StdError),
+
+    /// Epoch service.
+    #[error("epoch service error")]
+    EpochService(#[source] StdError),
 
     /// Signer registration failed.
     #[error("signer registration failed")]

mithril-aggregator/src/services/signer_registration/master.rs

@@ -147,7 +147,7 @@ impl SignerRegisterer for MithrilSignerRegistrationMaster {
                     registration_round.epoch
                 )
             })
-            .map_err(|e| SignerRegistrationError::StoreError(anyhow!(e)))?
+            .map_err(|e| SignerRegistrationError::Store(anyhow!(e)))?
         {
             Some(_) => Err(SignerRegistrationError::ExistingSigner(Box::new(
                 signer_save,