RPC messages work on ConfirmedBlockCertificates (#2976)

* RPC messages work on ConfirmedBlockCertificates

* RM singular DownloadCertificate RPC query.

* Ensure that we get correct number of certs in resposen.

* Don't Box Vectors,

* RM unnecessary conversion

* Error contains CryptoHash type

* Map ConfirmedBlockCertificate to Certificate before serializing

* Obliterate CertificateValue for real this time (#2988)

* Remove CertificateValue and change Certificate encoding.

* Review part 1

* Update linera-chain/src/certificate/mod.rs

Co-authored-by: Andreas Fackler <[email protected]>
Signed-off-by: deuszx <[email protected]>

---------

Signed-off-by: deuszx <[email protected]>
Co-authored-by: Andreas Fackler <[email protected]>

* Use ensure macro.

* Update linera-rpc/src/grpc/client.rs

Co-authored-by: Andreas Fackler <[email protected]>
Signed-off-by: deuszx <[email protected]>

* Import ensure

---------

Signed-off-by: deuszx <[email protected]>
Co-authored-by: Andreas Fackler <[email protected]>

Author: deuszx

examples/hex-game/tests/hex_game.rs

@@ -31,7 +31,7 @@ async fn hex_game() {
         })
         .await;
 
-    let executed_block = certificate.inner().executed_block().unwrap();
+    let executed_block = certificate.inner().executed_block();
     let message_id = executed_block.message_id_for_operation(0, 0).unwrap();
     let description = ChainDescription::Child(message_id);
     let mut chain = ActiveChain::new(key_pair1.copy(), description, validator);
@@ -105,7 +105,7 @@ async fn hex_game_clock() {
         })
         .await;
 
-    let executed_block = certificate.inner().executed_block().unwrap();
+    let executed_block = certificate.inner().executed_block();
     let message_id = executed_block.message_id_for_operation(0, 0).unwrap();
     let description = ChainDescription::Child(message_id);
     let mut chain = ActiveChain::new(key_pair1.copy(), description, validator.clone());

linera-chain/src/block.rs

@@ -13,11 +13,7 @@ use linera_execution::committee::Epoch;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::{
-    data_types::ExecutedBlock,
-    types::{CertificateValue, Hashed, HashedCertificateValue},
-    ChainError,
-};
+use crate::{data_types::ExecutedBlock, types::Hashed, ChainError};
 
 /// Wrapper around an `ExecutedBlock` that has been validated.
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]
@@ -32,7 +28,7 @@ impl ValidatedBlock {
     }
 
     /// Returns a reference to the `ExecutedBlock` contained in this `ValidatedBlock`.
-    pub fn inner(&self) -> &ExecutedBlock {
+    pub fn executed_block(&self) -> &ExecutedBlock {
         &self.executed_block
     }
 
@@ -48,20 +44,6 @@ impl ValidatedBlock {
 
 impl BcsHashable for ValidatedBlock {}
 
-impl TryFrom<HashedCertificateValue> for Hashed<ValidatedBlock> {
-    type Error = ConversionError;
-
-    fn try_from(value: HashedCertificateValue) -> Result<Self, Self::Error> {
-        let hash = value.hash();
-        match value.into_inner() {
-            CertificateValue::ValidatedBlock(validated) => {
-                Ok(Hashed::unchecked_new(validated, hash))
-            }
-            _ => Err(ConversionError::ValidatedBlock),
-        }
-    }
-}
-
 /// Wrapper around an `ExecutedBlock` that has been confirmed.
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]
 pub struct ConfirmedBlock {
@@ -94,29 +76,9 @@ impl Hashed<ConfirmedBlock> {
     }
 }
 
-impl TryFrom<HashedCertificateValue> for Hashed<ConfirmedBlock> {
-    type Error = ConversionError;
-
-    fn try_from(value: HashedCertificateValue) -> Result<Self, Self::Error> {
-        let hash = value.hash();
-        match value.into_inner() {
-            CertificateValue::ConfirmedBlock(confirmed) => {
-                Ok(Hashed::unchecked_new(confirmed, hash))
-            }
-            _ => Err(ConversionError::ConfirmedBlock),
-        }
-    }
-}
-
 impl BcsHashable for ConfirmedBlock {}
 
 impl ConfirmedBlock {
-    #[cfg(not(feature = "benchmark"))]
-    pub(super) fn new(executed_block: ExecutedBlock) -> Self {
-        Self { executed_block }
-    }
-
-    #[cfg(feature = "benchmark")]
     pub fn new(executed_block: ExecutedBlock) -> Self {
         Self { executed_block }
     }
@@ -140,6 +102,14 @@ impl ConfirmedBlock {
         self.executed_block
     }
 
+    pub fn chain_id(&self) -> ChainId {
+        self.executed_block.block.chain_id
+    }
+
+    pub fn height(&self) -> BlockHeight {
+        self.executed_block.block.height
+    }
+
     pub fn to_log_str(&self) -> &'static str {
         "confirmed_block"
     }
@@ -189,27 +159,20 @@ impl Timeout {
     }
 }
 
-impl TryFrom<HashedCertificateValue> for Hashed<Timeout> {
-    type Error = &'static str;
-    fn try_from(value: HashedCertificateValue) -> Result<Hashed<Timeout>, Self::Error> {
-        let hash = value.hash();
-        match value.into_inner() {
-            CertificateValue::Timeout(timeout) => Ok(Hashed::unchecked_new(timeout, hash)),
-            _ => Err("Expected a Timeout value"),
-        }
-    }
-}
-
 impl BcsHashable for Timeout {}
 
-/// Failure to convert a [`HashedCertificateValue`] into one of the block types.
+/// Failure to convert a `Certificate` into one of the expected certificate types.
 #[derive(Clone, Copy, Debug, Error)]
 pub enum ConversionError {
-    /// Failure to convert to [`ConfirmedBlock`].
-    #[error("Expected a `ConfirmedBlock` value")]
+    /// Failure to convert to [`ConfirmedBlock`] certificate.
+    #[error("Expected a `ConfirmedBlockCertificate` value")]
     ConfirmedBlock,
 
-    /// Failure to convert to [`ValidatedBlock`].
-    #[error("Expected a `ValidatedBlock` value")]
+    /// Failure to convert to [`ValidatedBlock`] certificate.
+    #[error("Expected a `ValidatedBlockCertificate` value")]
     ValidatedBlock,
+
+    /// Failure to convert to [`Timeout`] certificate.
+    #[error("Expected a `TimeoutCertificate` value")]
+    Timeout,
 }

linera-chain/src/certificate/confirmed.rs

@@ -2,31 +2,21 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use linera_base::identifiers::{BlobId, ChainId, MessageId};
-use linera_execution::committee::Epoch;
-
-use super::{
-    generic::GenericCertificate, hashed::Hashed, Certificate, CertificateValue,
-    HashedCertificateValue,
+use linera_base::{
+    crypto::Signature,
+    data_types::Round,
+    identifiers::{BlobId, ChainId, MessageId},
 };
+use linera_execution::committee::{Epoch, ValidatorName};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize};
+
+use super::{generic::GenericCertificate, hashed::Hashed, Certificate};
 use crate::{
-    block::{ConfirmedBlock, ConversionError, ValidatedBlock},
+    block::{ConfirmedBlock, ConversionError},
     data_types::{ExecutedBlock, Medium, MessageBundle},
 };
 
 impl GenericCertificate<ConfirmedBlock> {
-    /// Creates a new `ConfirmedBlockCertificate` from a `ValidatedBlockCertificate`.
-    pub fn from_validated(validated: GenericCertificate<ValidatedBlock>) -> Self {
-        let round = validated.round;
-        let validated_block = validated.into_inner();
-        // To keep the signature checks passing, we need to obtain a hash over the old type.
-        let old_confirmed = HashedCertificateValue::new_confirmed(validated_block.inner().clone());
-        let confirmed = ConfirmedBlock::from_validated(validated_block);
-        let hashed = Hashed::unchecked_new(confirmed, old_confirmed.hash());
-
-        Self::new(hashed, round, vec![])
-    }
-
     /// Returns reference to the `ExecutedBlock` contained in this certificate.
     pub fn executed_block(&self) -> &ExecutedBlock {
         self.inner().executed_block()
@@ -54,31 +44,61 @@ impl GenericCertificate<ConfirmedBlock> {
     pub fn requires_blob(&self, blob_id: &BlobId) -> bool {
         self.executed_block().requires_blob(blob_id)
     }
+
+    #[cfg(with_testing)]
+    pub fn outgoing_message_count(&self) -> usize {
+        self.executed_block().messages().iter().map(Vec::len).sum()
+    }
 }
 
 impl TryFrom<Certificate> for GenericCertificate<ConfirmedBlock> {
     type Error = ConversionError;
 
     fn try_from(cert: Certificate) -> Result<Self, Self::Error> {
-        let hash = cert.hash();
-        let (value, round, signatures) = cert.destructure();
-        match value.into_inner() {
-            CertificateValue::ConfirmedBlock(confirmed) => Ok(Self::new(
-                Hashed::unchecked_new(confirmed, hash),
-                round,
-                signatures,
-            )),
+        match cert {
+            Certificate::Confirmed(confirmed) => Ok(confirmed),
             _ => Err(ConversionError::ConfirmedBlock),
         }
     }
 }
 
 impl From<GenericCertificate<ConfirmedBlock>> for Certificate {
     fn from(cert: GenericCertificate<ConfirmedBlock>) -> Certificate {
-        let (value, round, signatures) = cert.destructure();
-        let hash = value.hash();
-        let value =
-            Hashed::unchecked_new(CertificateValue::ConfirmedBlock(value.into_inner()), hash);
-        Certificate::new(value, round, signatures)
+        Certificate::Confirmed(cert)
+    }
+}
+
+impl Serialize for GenericCertificate<ConfirmedBlock> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("ConfirmedBlockCertificate", 3)?;
+        state.serialize_field("value", self.inner())?;
+        state.serialize_field("round", &self.round)?;
+        state.serialize_field("signatures", self.signatures())?;
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for GenericCertificate<ConfirmedBlock> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Debug, Deserialize)]
+        #[serde(rename = "ConfirmedBlockCertificate")]
+        struct Helper {
+            value: Hashed<ConfirmedBlock>,
+            round: Round,
+            signatures: Vec<(ValidatorName, Signature)>,
+        }
+
+        let helper = Helper::deserialize(deserializer)?;
+        if !crate::data_types::is_strictly_ordered(&helper.signatures) {
+            Err(serde::de::Error::custom("Vector is not strictly sorted"))
+        } else {
+            Ok(Self::new(helper.value, helper.round, helper.signatures))
+        }
     }
 }