feat(common): encode SNARK aggregate signature as bytes

Encode the multi-signature by type: JSON-hex for concatenation (backward compatible), bytes-hex for SNARK and IVC proofs.

Author: jpraynaud

mithril-common/src/messages/certificate.rs

@@ -1,6 +1,7 @@
 use std::fmt::{Debug, Formatter};
 
 use anyhow::Context;
+use mithril_stm::AggregateSignatureType;
 use serde::{Deserialize, Serialize};
 
 use crate::StdError;
@@ -270,7 +271,7 @@ impl TryFrom<Certificate> for CertificateMessage {
         let (multi_signature, genesis_signature) = match certificate.signature {
             CertificateSignature::GenesisSignature(signature) => (
                 String::new(),
-                signature.to_bytes_hex().with_context(|| {
+                String::try_from(&signature).with_context(|| {
                     "Can not convert certificate to message: can not encode the genesis signature"
                 })?,
             ),
@@ -279,17 +280,31 @@ impl TryFrom<Certificate> for CertificateMessage {
                 genesis_schnorr_signature = hex::encode(schnorr_signature.to_bytes());
                 (
                     String::new(),
-                    ed_signature.to_bytes_hex().with_context(|| {
+                    String::try_from(&ed_signature).with_context(|| {
                         "Can not convert certificate to message: can not encode the genesis signature"
                     })?,
                 )
             }
-            CertificateSignature::MultiSignature(_, signature) => (
-                signature.to_json_hex().with_context(|| {
+            CertificateSignature::MultiSignature(_, signature) => {
+                // Temporary workaround: encode the multi-signature per aggregate signature type
+                // instead of natively through the ProtocolKey codec (`String::try_from(&signature)`).
+                // The bytes encoding of an aggregate signature is only decodable by clients from
+                // distribution 2617.0 onwards, so concatenation multi-signatures must stay JSON-hex
+                // until the older distributions (up to 2603.1) are retired. Once they are, register
+                // `AggregateSignature` under `bytes_hex_codec` and replace this match with
+                // `String::try_from(&signature)`.
+                let encoded_multi_signature = match AggregateSignatureType::from(&*signature) {
+                    AggregateSignatureType::Concatenation => signature.to_json_hex(),
+                    #[cfg(feature = "future_snark")]
+                    AggregateSignatureType::Snark | AggregateSignatureType::IvcSnark => {
+                        signature.to_bytes_hex()
+                    }
+                }
+                .with_context(|| {
                     "Can not convert certificate to message: can not encode the multi-signature"
-                })?,
-                String::new(),
-            ),
+                })?;
+                (encoded_multi_signature, String::new())
+            }
         };
 
         let message = CertificateMessage {
@@ -694,4 +709,45 @@ mod tests {
             }
         }
     }
+
+    mod multi_signature_encoding {
+        use crate::test::double::fake_data;
+
+        use super::*;
+
+        #[test]
+        fn concatenation_multi_signature_is_encoded_as_json_hex() {
+            let certificate = fake_data::certificate("hash");
+            let expected_json_hex = match &certificate.signature {
+                CertificateSignature::MultiSignature(_, signature) => {
+                    signature.to_json_hex().unwrap()
+                }
+                _ => panic!("expected a multi-signature certificate"),
+            };
+
+            let message = CertificateMessage::try_from(certificate).unwrap();
+
+            assert_eq!(expected_json_hex, message.multi_signature);
+        }
+
+        #[cfg(feature = "future_snark")]
+        #[test]
+        fn snark_multi_signature_is_encoded_as_bytes_hex() {
+            let snark_signature = fake_data::snark_aggregate_signature();
+            let expected_bytes_hex = snark_signature.to_bytes_hex().unwrap();
+            let mut certificate = fake_data::certificate("hash");
+            let signed_entity_type = match &certificate.signature {
+                CertificateSignature::MultiSignature(signed_entity_type, _) => {
+                    signed_entity_type.clone()
+                }
+                _ => panic!("expected a multi-signature certificate"),
+            };
+            certificate.signature =
+                CertificateSignature::MultiSignature(signed_entity_type, snark_signature);
+
+            let message = CertificateMessage::try_from(certificate).unwrap();
+
+            assert_eq!(expected_bytes_hex, message.multi_signature);
+        }
+    }
 }