Depreciate signers, next_signers, protocol_parameters and next_protocol_parameters from CertificatePendingMessage`

Author: sfauvel

mithril-common/src/entities/certificate_pending.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::entities::{Epoch, PartyId, ProtocolParameters, SignedEntityType, Signer};
+use crate::entities::{Epoch, ProtocolParameters, SignedEntityType, Signer};
 
 /// CertificatePending represents a pending certificate in the process of production
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -46,31 +46,4 @@ impl CertificatePending {
             next_signers,
         }
     }
-
-    /// get a signer from the certificate pending if it has registered
-    pub fn get_signer(&self, party_id: PartyId) -> Option<&Signer> {
-        self.signers.iter().find(|s| s.party_id == party_id)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::test_utils::fake_data;
-
-    use super::*;
-
-    #[test]
-    fn certificate_pending_get_signers() {
-        let certificate_pending = {
-            let mut signers = fake_data::signers(3);
-            signers[0].party_id = "1".to_string();
-            CertificatePending {
-                signers,
-                ..fake_data::certificate_pending()
-            }
-        };
-
-        assert!(certificate_pending.get_signer("1".to_string()).is_some());
-        assert!(certificate_pending.get_signer("5".to_string()).is_none());
-    }
 }

mithril-common/src/messages/certificate_pending.rs

@@ -19,17 +19,33 @@ pub struct CertificatePendingMessage {
     pub signed_entity_type: SignedEntityType,
 
     /// Current Protocol parameters
+    #[deprecated(
+        since = "0.4.47",
+        note = "Exist only for backward-compatibility, will be removed in the future"
+    )]
     #[serde(rename = "protocol")]
     pub protocol_parameters: ProtocolParameters,
 
     /// Next Protocol parameters
+    #[deprecated(
+        since = "0.4.47",
+        note = "Exist only for backward-compatibility, will be removed in the future"
+    )]
     #[serde(rename = "next_protocol")]
     pub next_protocol_parameters: ProtocolParameters,
 
-    /// Current Signers
+    /// Current Signers    
+    #[deprecated(
+        since = "0.4.47",
+        note = "Exist only for backward-compatibility, will be removed in the future"
+    )]
     pub signers: Vec<SignerMessagePart>,
 
     /// Signers that will be able to sign on the next epoch
+    #[deprecated(
+        since = "0.4.47",
+        note = "Exist only for backward-compatibility, will be removed in the future"
+    )]
     pub next_signers: Vec<SignerMessagePart>,
 }
 

mithril-signer/src/message_adapters/from_pending_certificate_message.rs

@@ -59,6 +59,7 @@ impl TryFromMessageAdapter<CertificatePendingMessage, CertificatePending>
         let certificate = CertificatePending {
             epoch: message.epoch,
             signed_entity_type: message.signed_entity_type,
+            // TODO XXX do not use `message` to fill those fields which must not be used anymore.
             protocol_parameters: message.protocol_parameters,
             next_protocol_parameters: message.next_protocol_parameters,
             signers: to_signers(&message.signers).with_context(|| {

mithril-signer/src/runtime/runner.rs

@@ -299,9 +299,23 @@ impl Runner for SignerRunner {
             return Ok(false);
         }
 
-        if let Some(signer) =
-            pending_certificate.get_signer(self.services.single_signer.get_party_id())
-        {
+        // TODO XXX How handle errors ? It occurs in test_create_immutable_files_full_single_signature integration test (no signers in epoch 1)
+        // TODO XXX Do we warn and return "can not sign" or return an error ?
+        let current_signer_with_stake: Option<SignerWithStake> = {
+            let epoch_service = self.services.epoch_service.read().await;
+            let current_signers = epoch_service.current_signers_with_stake().await;
+            if let Ok(signers) = current_signers {
+                signers
+                    .iter()
+                    .find(|s| s.party_id == self.services.single_signer.get_party_id())
+                    .cloned()
+            } else {
+                warn!(" > could not get current signers with stake, can NOT sign");
+                return Ok(false);
+            }
+        };
+
+        if let Some(signer) = current_signer_with_stake {
             debug!(" > got a Signer from pending certificate");
 
             if let Some(protocol_initializer) = self
@@ -502,7 +516,7 @@ mod tests {
             MKMap, MKMapNode, MKTreeNode, MKTreeStoreInMemory, MKTreeStorer, ProtocolInitializer,
         },
         digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
-        entities::{BlockNumber, BlockRange, CardanoDbBeacon, Epoch},
+        entities::{BlockNumber, BlockRange, CardanoDbBeacon, Epoch, StakeDistribution},
         era::{adapters::EraReaderBootstrapAdapter, EraChecker, EraReader},
         signable_builder::{
             BlockRangeRootRetriever, CardanoImmutableFilesFullSignableBuilder,
@@ -764,16 +778,35 @@ mod tests {
 
     #[tokio::test]
     async fn test_can_i_sign() {
+        let signers_with_stake = fake_data::signers_with_stakes(5);
+        let signers = Signer::vec_from(signers_with_stake.to_vec());
+        let stake_distribution = signers_with_stake
+            .iter()
+            .map(|signer| (signer.party_id.clone(), signer.stake))
+            .collect();
+
+        let mut current_signers = signers[1..3].to_vec();
+        let next_signers = signers[2..5].to_vec();
+
         let mut pending_certificate = fake_data::certificate_pending();
+        pending_certificate.signers = vec![];
+        pending_certificate.next_signers = vec![];
         let epoch = pending_certificate.epoch;
-        let signer = &mut pending_certificate.signers[0];
-        // All signed entities are available for signing.
+        let signer = &mut current_signers[0];
+
         let signed_entity_type_lock = Arc::new(SignedEntityTypeLock::new());
         let mut services = init_services().await;
         let protocol_initializer_store = services.protocol_initializer_store.clone();
         services.single_signer = Arc::new(MithrilSingleSigner::new(signer.party_id.to_owned()));
         services.signed_entity_type_lock = signed_entity_type_lock.clone();
-        let runner = init_runner(Some(services), None).await;
+        services
+            .stake_store
+            .save_stakes(
+                epoch.offset_to_signer_retrieval_epoch().unwrap(),
+                stake_distribution,
+            )
+            .await
+            .expect("save_stakes should not fail");
 
         let protocol_initializer = MithrilProtocolInitializerBuilder::build(
             &100,
@@ -793,6 +826,16 @@ mod tests {
             .await
             .expect("save_protocol_initializer should not fail");
 
+        let runner = init_runner(Some(services), None).await;
+        // inform epoch settings
+        let epoch_settings = EpochSettings {
+            epoch,
+            current_signers,
+            next_signers,
+            ..fake_data::epoch_settings().clone()
+        };
+        runner.inform_epoch_settings(epoch_settings).await.unwrap();
+
         let can_i_sign_result = runner.can_i_sign(&pending_certificate).await.unwrap();
         assert!(can_i_sign_result);
 

mithril-signer/src/services/epoch_service.rs

@@ -134,6 +134,7 @@ impl EpochService for MithrilEpochService {
 
         self.epoch_data = Some(EpochData {
             epoch: epoch_settings.epoch,
+            // TODO XXX Do we need protocol parameters ?
             next_protocol_parameters: epoch_settings.next_protocol_parameters,
             current_signers: epoch_settings.current_signers,
             next_signers: epoch_settings.next_signers,

openapi.yaml

@@ -843,14 +843,18 @@ components:
         entity_type:
           $ref: "#/components/schemas/SignedEntityType"
         protocol:
+          deprecated: true
           $ref: "#/components/schemas/ProtocolParameters"
         next_protocol:
+          deprecated: true
           $ref: "#/components/schemas/ProtocolParameters"
         signers:
+          deprecated: true
           type: array
           items:
             $ref: "#/components/schemas/Signer"
         next_signers:
+          deprecated: true
           type: array
           items:
             $ref: "#/components/schemas/Signer"