refactor(e2e): use signer relay modes in e2e test

Author: jpraynaud

Diff for: Cargo.lock

@@ -21,6 +21,7 @@ clap = { version = "4.5.28", features = ["derive"] }
 indicatif = { version = "0.17.11", features = ["tokio"] }
 mithril-common = { path = "../../mithril-common", features = ["full"] }
 mithril-doc = { path = "../../internal/mithril-doc" }
+mithril-relay = { path = "../../mithril-relay"}
 reqwest = { version = "0.12.12", features = ["json"] }
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.138"

Diff for: mithril-test-lab/mithril-end-to-end/Cargo.toml

@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Context};
 use clap::{CommandFactory, Parser, Subcommand};
+use mithril_relay::SignerRelayMode;
 use slog::{Drain, Level, Logger};
 use slog_scope::{error, info};
 use std::{
@@ -107,11 +108,19 @@ pub struct Args {
     #[clap(long)]
     run_only: bool,
 
-    /// Enable P2P network mode
+    /// Use Mithril relays
     #[clap(long)]
-    use_p2p_network: bool,
+    use_relays: bool,
 
-    /// Enable P2P passive relays in P2P mode
+    /// Signer registration relay mode (used only when 'use_relays' is set)
+    #[clap(long, value_enum, default_value_t = SignerRelayMode::Passthrough)]
+    relay_signer_registration_mode: SignerRelayMode,
+
+    /// Signature registration relay mode (used only when 'use_relays' is set)
+    #[clap(long, value_enum, default_value_t = SignerRelayMode::P2P)]
+    relay_signature_registration_mode: SignerRelayMode,
+
+    /// Enable P2P passive relays in P2P mode (used only when 'use_relays' is set)
     #[clap(long, default_value = "true")]
     use_p2p_passive_relays: bool,
 
@@ -147,9 +156,9 @@ impl Args {
         if self.number_of_signers == 0 {
             return Err(anyhow!("At least one signer is required"));
         }
-        if !self.use_p2p_network && self.number_of_aggregators >= 2 {
+        if !self.use_relays && self.number_of_aggregators >= 2 {
             return Err(anyhow!(
-                "The P2P mode must be activated to run more than one aggregator"
+                "The 'use_relays' parameter must be activated to run more than one aggregator"
             ));
         }
 
@@ -324,7 +333,10 @@ impl App {
         let server_port = 8080;
         args.validate()?;
         let run_only_mode = args.run_only;
-        let use_p2p_network_mode = args.use_p2p_network;
+        let use_relays = args.use_relays;
+        let relay_signer_registration_mode = args.relay_signer_registration_mode;
+        let relay_signature_registration_mode = args.relay_signature_registration_mode;
+
         let use_p2p_passive_relays = args.use_p2p_passive_relays;
 
         let devnet = Devnet::bootstrap(&DevnetBootstrapArgs {
@@ -355,7 +367,9 @@ impl App {
             mithril_era_reader_adapter: args.mithril_era_reader_adapter,
             signed_entity_types: args.signed_entity_types.clone(),
             run_only_mode,
-            use_p2p_network_mode,
+            use_relays,
+            relay_signer_registration_mode,
+            relay_signature_registration_mode,
             use_p2p_passive_relays,
             use_era_specific_work_dir: args.mithril_next_era.is_some(),
         })
@@ -519,7 +533,7 @@ mod tests {
             "validate should fail with more than one aggregator if p2p network is not used",
         );
 
-        let args = Args::parse_from(["", "--use-p2p-network", "--number-of-aggregators", "2"]);
+        let args = Args::parse_from(["", "--use-relays", "--number-of-aggregators", "2"]);
         args.validate()
             .expect("validate should succeed with more than one aggregator if p2p network is used");
     }

Diff for: mithril-test-lab/mithril-end-to-end/src/main.rs

@@ -1,17 +1,18 @@
+use crate::mithril::relay_signer::RelaySignerConfiguration;
+use crate::{
+    assertions, Aggregator, AggregatorConfig, Client, Devnet, PoolNode, RelayAggregator,
+    RelayPassive, RelaySigner, Signer, DEVNET_MAGIC_ID,
+};
 use mithril_common::chain_observer::{ChainObserver, PallasChainObserver};
 use mithril_common::entities::{Epoch, PartyId, ProtocolParameters};
 use mithril_common::{CardanoNetwork, StdResult};
+use mithril_relay::SignerRelayMode;
 use slog_scope::info;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::{
-    assertions, Aggregator, AggregatorConfig, Client, Devnet, PoolNode, RelayAggregator,
-    RelayPassive, RelaySigner, Signer, DEVNET_MAGIC_ID,
-};
-
 use super::signer::SignerConfig;
 
 pub struct MithrilInfrastructureConfig {
@@ -29,7 +30,9 @@ pub struct MithrilInfrastructureConfig {
     pub mithril_era_reader_adapter: String,
     pub signed_entity_types: Vec<String>,
     pub run_only_mode: bool,
-    pub use_p2p_network_mode: bool,
+    pub use_relays: bool,
+    pub relay_signer_registration_mode: SignerRelayMode,
+    pub relay_signature_registration_mode: SignerRelayMode,
     pub use_p2p_passive_relays: bool,
     pub use_era_specific_work_dir: bool,
 }
@@ -64,6 +67,8 @@ impl MithrilInfrastructure {
             .iter()
             .map(|s| s.party_id())
             .collect::<StdResult<Vec<PartyId>>>()?;
+        let relay_signer_registration_mode = &config.relay_signer_registration_mode;
+        let relay_signature_registration_mode = &config.relay_signature_registration_mode;
 
         let aggregators =
             Self::start_aggregators(config, aggregator_cardano_nodes, chain_observer_type).await?;
@@ -73,8 +78,13 @@ impl MithrilInfrastructure {
             .collect::<Vec<_>>();
         let master_aggregator_endpoint = aggregator_endpoints[0].to_owned();
 
-        let (relay_aggregators, relay_signers, relay_passives) =
-            Self::start_relays(config, &aggregator_endpoints, &signer_party_ids)?;
+        let (relay_aggregators, relay_signers, relay_passives) = Self::start_relays(
+            config,
+            &aggregator_endpoints,
+            &signer_party_ids,
+            relay_signer_registration_mode.to_owned(),
+            relay_signature_registration_mode.to_owned(),
+        )?;
 
         let signers = Self::start_signers(
             config,
@@ -219,8 +229,10 @@ impl MithrilInfrastructure {
         config: &MithrilInfrastructureConfig,
         aggregator_endpoints: &[String],
         signers_party_ids: &[PartyId],
+        relay_signer_registration_mode: SignerRelayMode,
+        relay_signature_registration_mode: SignerRelayMode,
     ) -> StdResult<(Vec<RelayAggregator>, Vec<RelaySigner>, Vec<RelayPassive>)> {
-        if !config.use_p2p_network_mode {
+        if !config.use_relays {
             return Ok((vec![], vec![], vec![]));
         }
 
@@ -249,15 +261,17 @@ impl MithrilInfrastructure {
         }
 
         for (index, party_id) in signers_party_ids.iter().enumerate() {
-            let mut relay_signer = RelaySigner::new(
-                config.server_port + index as u64 + 200,
-                config.server_port + index as u64 + 300,
-                bootstrap_peer_addr.clone(),
-                master_aggregator_endpoint,
-                party_id.clone(),
-                &config.work_dir,
-                &config.bin_dir,
-            )?;
+            let mut relay_signer = RelaySigner::new(&RelaySignerConfiguration {
+                listen_port: config.server_port + index as u64 + 200,
+                server_port: config.server_port + index as u64 + 300,
+                dial_to: bootstrap_peer_addr.clone(),
+                relay_signer_registration_mode: relay_signer_registration_mode.clone(),
+                relay_signature_registration_mode: relay_signature_registration_mode.clone(),
+                aggregator_endpoint: master_aggregator_endpoint,
+                party_id: party_id.clone(),
+                work_dir: &config.work_dir,
+                bin_dir: &config.bin_dir,
+            })?;
             relay_signer.start()?;
 
             relay_signers.push(relay_signer);
@@ -308,7 +322,7 @@ impl MithrilInfrastructure {
             // Or 100% of signers otherwise
             let enable_certification =
                 index % 2 == 0 || cfg!(not(feature = "allow_skip_signer_certification"));
-            let aggregator_endpoint = if config.use_p2p_network_mode {
+            let aggregator_endpoint = if config.use_relays {
                 relay_signers[index].endpoint()
             } else {
                 master_aggregator_endpoint.clone()

Diff for: mithril-test-lab/mithril-end-to-end/src/mithril/infrastructure.rs

@@ -1,10 +1,23 @@
 use crate::utils::MithrilCommand;
 use mithril_common::entities::PartyId;
 use mithril_common::StdResult;
+use mithril_relay::SignerRelayMode;
 use std::collections::HashMap;
 use std::path::Path;
 use tokio::process::Child;
 
+pub struct RelaySignerConfiguration<'a> {
+    pub listen_port: u64,
+    pub server_port: u64,
+    pub dial_to: Option<String>,
+    pub relay_signer_registration_mode: SignerRelayMode,
+    pub relay_signature_registration_mode: SignerRelayMode,
+    pub aggregator_endpoint: &'a str,
+    pub party_id: PartyId,
+    pub work_dir: &'a Path,
+    pub bin_dir: &'a Path,
+}
+
 #[derive(Debug)]
 pub struct RelaySigner {
     listen_port: u64,
@@ -15,35 +28,45 @@ pub struct RelaySigner {
 }
 
 impl RelaySigner {
-    pub fn new(
-        listen_port: u64,
-        server_port: u64,
-        dial_to: Option<String>,
-        aggregator_endpoint: &str,
-        party_id: PartyId,
-        work_dir: &Path,
-        bin_dir: &Path,
-    ) -> StdResult<Self> {
-        let listen_port_str = format!("{listen_port}");
-        let server_port_str = format!("{server_port}");
+    pub fn new(configuration: &RelaySignerConfiguration) -> StdResult<Self> {
+        let listen_port_str = format!("{}", configuration.listen_port);
+        let server_port_str = format!("{}", configuration.server_port);
+        let relay_signer_registration_mode =
+            configuration.relay_signer_registration_mode.to_string();
+        let relay_signature_registration_mode =
+            configuration.relay_signature_registration_mode.to_string();
         let mut env = HashMap::from([
             ("LISTEN_PORT", listen_port_str.as_str()),
             ("SERVER_PORT", server_port_str.as_str()),
-            ("AGGREGATOR_ENDPOINT", aggregator_endpoint),
+            ("AGGREGATOR_ENDPOINT", configuration.aggregator_endpoint),
             ("SIGNER_REPEATER_DELAY", "100"),
+            (
+                "SIGNER_REGISTRATION_MODE",
+                relay_signer_registration_mode.as_str(),
+            ),
+            (
+                "SIGNATURE_REGISTRATION_MODE",
+                relay_signature_registration_mode.as_str(),
+            ),
         ]);
-        if let Some(dial_to) = &dial_to {
+        if let Some(dial_to) = &configuration.dial_to {
             env.insert("DIAL_TO", dial_to);
         }
         let args = vec!["-vvv", "signer"];
 
-        let mut command = MithrilCommand::new("mithril-relay", work_dir, bin_dir, env, &args)?;
-        command.set_log_name(format!("mithril-relay-signer-{party_id}").as_str());
+        let mut command = MithrilCommand::new(
+            "mithril-relay",
+            configuration.work_dir,
+            configuration.bin_dir,
+            env,
+            &args,
+        )?;
+        command.set_log_name(format!("mithril-relay-signer-{}", configuration.party_id).as_str());
 
         Ok(Self {
-            listen_port,
-            server_port,
-            party_id,
+            listen_port: configuration.listen_port,
+            server_port: configuration.server_port,
+            party_id: configuration.party_id.to_owned(),
             command,
             process: None,
         })