Make signer send signed entity types with signatures

Author: jpraynaud

mithril-signer/src/certificate_handler.rs

@@ -6,7 +6,9 @@ use thiserror::Error;
 
 use mithril_common::{
     api_version::APIVersionProvider,
-    entities::{CertificatePending, Epoch, EpochSettings, Signer, SingleSignatures},
+    entities::{
+        CertificatePending, Epoch, EpochSettings, SignedEntityType, Signer, SingleSignatures,
+    },
     messages::{CertificatePendingMessage, EpochSettingsMessage},
     MITHRIL_API_VERSION_HEADER, MITHRIL_SIGNER_VERSION_HEADER,
 };
@@ -79,6 +81,7 @@ pub trait CertificateHandler: Sync + Send {
     /// Registers single signatures with the aggregator.
     async fn register_signatures(
         &self,
+        signed_entity_type: &SignedEntityType,
         signatures: &SingleSignatures,
     ) -> Result<(), CertificateHandlerError>;
 }
@@ -220,12 +223,15 @@ impl CertificateHandler for CertificateHandlerHTTPClient {
 
     async fn register_signatures(
         &self,
+        signed_entity_type: &SignedEntityType,
         signatures: &SingleSignatures,
     ) -> Result<(), CertificateHandlerError> {
         debug!("Register signatures");
         let url = format!("{}/register-signatures", self.aggregator_endpoint);
-        let register_single_signature_message =
-            ToRegisterSignatureMessageAdapter::adapt(signatures.to_owned());
+        let register_single_signature_message = ToRegisterSignatureMessageAdapter::adapt(
+            signed_entity_type.to_owned(),
+            signatures.to_owned(),
+        );
         let response = self
             .prepare_request_builder(Client::new().post(url.clone()))
             .json(&register_single_signature_message)
@@ -346,6 +352,7 @@ pub(crate) mod dumb {
         /// Registers single signatures with the aggregator
         async fn register_signatures(
             &self,
+            _signed_entity_type: &SignedEntityType,
             _signatures: &SingleSignatures,
         ) -> Result<(), CertificateHandlerError> {
             Ok(())
@@ -635,7 +642,7 @@ mod tests {
             Arc::new(api_version_provider),
         );
         let register_signatures = certificate_handler
-            .register_signatures(&single_signatures)
+            .register_signatures(&SignedEntityType::dummy(), &single_signatures)
             .await;
         register_signatures.expect("unexpected error");
     }
@@ -654,7 +661,7 @@ mod tests {
             Arc::new(api_version_provider),
         );
         let error = certificate_handler
-            .register_signatures(&single_signatures)
+            .register_signatures(&SignedEntityType::dummy(), &single_signatures)
             .await
             .unwrap_err();
 
@@ -680,7 +687,7 @@ mod tests {
             Arc::new(api_version_provider),
         );
         let register_signatures = certificate_handler
-            .register_signatures(&single_signatures)
+            .register_signatures(&SignedEntityType::dummy(), &single_signatures)
             .await;
         assert_eq!(
             CertificateHandlerError::RemoteServerLogical(
@@ -704,7 +711,7 @@ mod tests {
             Arc::new(api_version_provider),
         );
         let register_signatures = certificate_handler
-            .register_signatures(&single_signatures)
+            .register_signatures(&SignedEntityType::dummy(), &single_signatures)
             .await;
         assert_eq!(
             CertificateHandlerError::RemoteServerLogical(
@@ -728,7 +735,7 @@ mod tests {
             Arc::new(api_version_provider),
         );
         let register_signatures = certificate_handler
-            .register_signatures(&single_signatures)
+            .register_signatures(&SignedEntityType::dummy(), &single_signatures)
             .await;
         assert_eq!(
             CertificateHandlerError::RemoteServerTechnical("an error occurred".to_string())

mithril-signer/src/message_adapters/to_register_signature_message.rs

@@ -1,12 +1,15 @@
-use mithril_common::entities::SingleSignatures;
+use mithril_common::entities::{SignedEntityType, SingleSignatures};
 use mithril_common::messages::RegisterSignatureMessage;
 
 pub struct ToRegisterSignatureMessageAdapter;
 
 impl ToRegisterSignatureMessageAdapter {
-    pub fn adapt(single_signature: SingleSignatures) -> RegisterSignatureMessage {
+    pub fn adapt(
+        signed_entity_type: SignedEntityType,
+        single_signature: SingleSignatures,
+    ) -> RegisterSignatureMessage {
         RegisterSignatureMessage {
-            signed_entity_type: None,
+            signed_entity_type: Some(signed_entity_type),
             party_id: single_signature.party_id,
             signature: single_signature.signature,
             won_indexes: single_signature.won_indexes,
@@ -23,7 +26,8 @@ mod tests {
     #[test]
     fn adapt_ok() {
         let single_signature = fake_data::single_signatures([1, 3].to_vec());
-        let message = ToRegisterSignatureMessageAdapter::adapt(single_signature);
+        let message =
+            ToRegisterSignatureMessageAdapter::adapt(SignedEntityType::dummy(), single_signature);
 
         assert_eq!("party_id".to_string(), message.party_id);
     }

mithril-signer/src/runtime/runner.rs

@@ -84,6 +84,7 @@ pub trait Runner {
     /// Send the single signature to the aggregator in order to be aggregated.
     async fn send_single_signature(
         &self,
+        signed_entity_type: &SignedEntityType,
         maybe_signature: Option<SingleSignatures>,
     ) -> Result<(), Box<dyn StdError + Sync + Send>>;
 
@@ -430,6 +431,7 @@ impl Runner for SignerRunner {
 
     async fn send_single_signature(
         &self,
+        signed_entity_type: &SignedEntityType,
         maybe_signature: Option<SingleSignatures>,
     ) -> Result<(), Box<dyn StdError + Sync + Send>> {
         debug!("RUNNER: send_single_signature");
@@ -438,7 +440,7 @@ impl Runner for SignerRunner {
             debug!(" > there is a single signature to send");
             self.services
                 .certificate_handler
-                .register_signatures(&single_signatures)
+                .register_signatures(signed_entity_type, &single_signatures)
                 .await
                 .map_err(|e| e.into())
         } else {
@@ -873,12 +875,15 @@ mod tests {
         certificate_handler
             .expect_register_signatures()
             .once()
-            .returning(|_| Ok(()));
+            .returning(|_, _| Ok(()));
         services.certificate_handler = Arc::new(certificate_handler);
         let runner = init_runner(Some(services), None).await;
 
         runner
-            .send_single_signature(Some(fake_data::single_signatures(vec![2, 5, 12])))
+            .send_single_signature(
+                &SignedEntityType::dummy(),
+                Some(fake_data::single_signatures(vec![2, 5, 12])),
+            )
             .await
             .expect("send_single_signature should not fail");
     }

mithril-signer/src/runtime/state_machine.rs

@@ -368,13 +368,13 @@ impl StateMachine {
             })?;
         let single_signatures = self
             .runner
-            .compute_single_signature(current_beacon.epoch, &message, &signers)
+            .compute_single_signature( current_beacon.epoch, &message, &signers)
             .await
             .map_err(|e| RuntimeError::KeepState {
                 message: format!("Could not compute single signature during 'registered → signed' phase (current beacon {current_beacon:?})"),
                 nested_error: Some(e)
             })?;
-        self.runner.send_single_signature(single_signatures).await
+        self.runner.send_single_signature(&pending_certificate.signed_entity_type, single_signatures).await
             .map_err(|e| RuntimeError::KeepState {
                 message: format!("Could not send single signature during 'registered → signed' phase (current beacon {current_beacon:?})"),
                 nested_error: Some(e)
@@ -646,7 +646,7 @@ mod tests {
         runner
             .expect_send_single_signature()
             .once()
-            .returning(|_| Ok(()));
+            .returning(|_, _| Ok(()));
 
         let mut state_machine = init_state_machine(state, runner);
         state_machine

mithril-signer/tests/test_extensions/certificate_handler.rs

@@ -2,7 +2,10 @@ use std::{collections::HashMap, sync::Arc};
 
 use async_trait::async_trait;
 use mithril_common::{
-    entities::{Beacon, CertificatePending, Epoch, EpochSettings, Signer, SingleSignatures},
+    entities::{
+        Beacon, CertificatePending, Epoch, EpochSettings, SignedEntityType, Signer,
+        SingleSignatures,
+    },
     test_utils::fake_data,
     BeaconProvider, BeaconProviderImpl,
 };
@@ -106,6 +109,7 @@ impl CertificateHandler for FakeAggregator {
     /// Registers single signatures with the aggregator
     async fn register_signatures(
         &self,
+        _signed_entity_type: &SignedEntityType,
         _signatures: &SingleSignatures,
     ) -> Result<(), CertificateHandlerError> {
         Ok(())