ValidatorNode::download_certificates returns ConfirmedBlockCertificates (#2973)

Author: deuszx

linera-core/src/client/mod.rs

@@ -1311,13 +1311,11 @@ where
 
         // Check the signatures and keep only the ones that are valid.
         let mut certificates = Vec::new();
-        for certificate in remote_certificates {
-            let sender_chain_id = certificate.inner().chain_id();
-            let height = certificate.inner().height();
-            let epoch = certificate.inner().epoch();
-            let confirmed_block_certificate = certificate
-                .try_into()
-                .map_err(|_| NodeError::UnexpectedCertificateValue)?;
+        for confirmed_block_certificate in remote_certificates {
+            let block = &confirmed_block_certificate.inner().executed_block().block;
+            let sender_chain_id = block.chain_id;
+            let height = block.height;
+            let epoch = block.epoch;
             match self.check_certificate(max_epoch, &committees, &confirmed_block_certificate)? {
                 CheckCertificateResult::FutureEpoch => {
                     warn!(

linera-core/src/node.rs

@@ -100,7 +100,7 @@ pub trait ValidatorNode {
     async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError>;
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError>;
 
     /// Returns the hash of the `Certificate` that last used a blob.
     async fn blob_last_used_by(&self, blob_id: BlobId) -> Result<CryptoHash, NodeError>;

linera-core/src/remote_node.rs

@@ -284,7 +284,7 @@ impl<N: ValidatorNode> RemoteNode<N> {
     pub async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
         if hashes.is_empty() {
             return Ok(Vec::new());
         }

linera-core/src/unit_tests/test_utils.rs

@@ -21,7 +21,7 @@ use linera_base::{
 };
 use linera_chain::{
     data_types::BlockProposal,
-    types::{Certificate, ConfirmedBlockCertificate, GenericCertificate, LiteCertificate},
+    types::{ConfirmedBlockCertificate, GenericCertificate, LiteCertificate},
 };
 use linera_execution::{
     committee::{Committee, ValidatorName},
@@ -176,12 +176,11 @@ where
     async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
         self.spawn_and_receive(move |validator, sender| {
             validator.do_download_certificates(hashes, sender)
         })
         .await
-        .map(|certs| certs.into_iter().map(Certificate::from).collect())
     }
 
     async fn blob_last_used_by(&self, blob_id: BlobId) -> Result<CryptoHash, NodeError> {

linera-rpc/src/client.rs

@@ -164,7 +164,7 @@ impl ValidatorNode for Client {
     async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
         Ok(match self {
             Client::Grpc(grpc_client) => grpc_client.download_certificates(hashes).await?,
 

linera-rpc/src/grpc/client.rs

@@ -339,14 +339,21 @@ impl ValidatorNode for GrpcClient {
     async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
         let mut missing_hashes = hashes;
         let mut certs_collected = Vec::with_capacity(missing_hashes.len());
         loop {
             // Macro doesn't compile if we pass `missing_hashes.clone()` directly to `client_delegate!`.
             let missing = missing_hashes.clone();
-            let mut received: Vec<Certificate> =
-                client_delegate!(self, download_certificates, missing)?.try_into()?;
+            let mut received: Vec<ConfirmedBlockCertificate> = Vec::<Certificate>::try_from(
+                client_delegate!(self, download_certificates, missing)?,
+            )?
+            .into_iter()
+            .map(|cert| {
+                ConfirmedBlockCertificate::try_from(cert)
+                    .map_err(|_| NodeError::UnexpectedCertificateValue)
+            })
+            .collect::<Result<_, _>>()?;
 
             // In the case of the server not returning any certificates, we break the loop.
             if received.is_empty() {

linera-rpc/src/simple/client.rs

@@ -158,9 +158,15 @@ impl ValidatorNode for SimpleClient {
     async fn download_certificates(
         &self,
         hashes: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
-        self.query(RpcMessage::DownloadCertificates(Box::new(hashes)))
-            .await
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
+        self.query::<Vec<Certificate>>(RpcMessage::DownloadCertificates(Box::new(hashes)))
+            .await?
+            .into_iter()
+            .map(|cert| {
+                cert.try_into()
+                    .map_err(|_| NodeError::UnexpectedCertificateValue)
+            })
+            .collect()
     }
 
     async fn blob_last_used_by(&self, blob_id: BlobId) -> Result<CryptoHash, NodeError> {

linera-service/src/schema_export.rs

@@ -9,7 +9,7 @@ use linera_base::{
 };
 use linera_chain::{
     data_types::BlockProposal,
-    types::{Certificate, ConfirmedBlockCertificate, GenericCertificate, LiteCertificate},
+    types::{ConfirmedBlockCertificate, GenericCertificate, LiteCertificate},
 };
 use linera_client::{
     chain_listener::{ChainListenerConfig, ClientContext},
@@ -93,7 +93,7 @@ impl ValidatorNode for DummyValidatorNode {
     async fn download_certificates(
         &self,
         _: Vec<CryptoHash>,
-    ) -> Result<Vec<Certificate>, NodeError> {
+    ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError> {
         Err(NodeError::UnexpectedMessage)
     }