Endpoint to download a Certificate

linera-core/src/node.rs

@@ -87,6 +87,8 @@ pub trait LocalValidatorNode {
         &mut self,
         hash: CryptoHash,
     ) -> Result<HashedCertificateValue, NodeError>;
+
+    async fn download_certificate(&mut self, hash: CryptoHash) -> Result<Certificate, NodeError>;
 }
 
 /// Turn an address into a validator node.

linera-core/src/unit_tests/test_utils.rs

@@ -168,6 +168,13 @@ where
         })
         .await
     }
+
+    async fn download_certificate(&mut self, hash: CryptoHash) -> Result<Certificate, NodeError> {
+        self.spawn_and_receive(move |validator, sender| {
+            validator.do_download_certificate(hash, sender)
+        })
+        .await
+    }
 }
 
 impl<S> LocalValidatorClient<S>
@@ -364,6 +371,23 @@ where
             .map_err(Into::into);
         sender.send(certificate_value)
     }
+
+    async fn do_download_certificate(
+        self,
+        hash: CryptoHash,
+        sender: oneshot::Sender<Result<Certificate, NodeError>>,
+    ) -> Result<(), Result<Certificate, NodeError>> {
+        let validator = self.client.lock().await;
+        let certificate = validator
+            .state
+            .storage_client()
+            .read_certificate(hash)
+            .await
+            .map(Into::into)
+            .map_err(Into::into);
+
+        sender.send(certificate)
+    }
 }
 
 #[derive(Clone)]

linera-rpc/proto/rpc.proto

@@ -57,6 +57,9 @@ service ValidatorNode {
 
   // Downloads a certificate value.
   rpc DownloadCertificateValue(CryptoHash) returns (CertificateValue);
+
+  // Downloads a certificate.
+  rpc DownloadCertificate(CryptoHash) returns (Certificate);
 }
 
 // Information about the Linera crate version the validator is running

linera-rpc/src/client.rs

@@ -166,4 +166,13 @@ impl ValidatorNode for Client {
             Client::Simple(simple_client) => simple_client.download_certificate_value(hash).await?,
         })
     }
+
+    async fn download_certificate(&mut self, hash: CryptoHash) -> Result<Certificate, NodeError> {
+        Ok(match self {
+            Client::Grpc(grpc_client) => grpc_client.download_certificate(hash).await?,
+
+            #[cfg(with_simple_network)]
+            Client::Simple(simple_client) => simple_client.download_certificate(hash).await?,
+        })
+    }
 }

linera-rpc/src/grpc/client.rs

@@ -9,7 +9,7 @@ use linera_base::{
     data_types::{Blob, HashedBlob},
     identifiers::{BlobId, ChainId},
 };
-use linera_chain::data_types::{self, CertificateValue, HashedCertificateValue};
+use linera_chain::data_types::{self, Certificate, CertificateValue, HashedCertificateValue};
 #[cfg(web)]
 use linera_core::node::{
     LocalNotificationStream as NotificationStream, LocalValidatorNode as ValidatorNode,
@@ -165,7 +165,7 @@ impl ValidatorNode for GrpcClient {
     #[instrument(target = "grpc_client", skip_all, err, fields(address = self.address))]
     async fn handle_certificate(
         &mut self,
-        certificate: data_types::Certificate,
+        certificate: Certificate,
         hashed_certificate_values: Vec<data_types::HashedCertificateValue>,
         hashed_blobs: Vec<HashedBlob>,
         delivery: CrossChainMessageDelivery,
@@ -289,6 +289,16 @@ impl ValidatorNode for GrpcClient {
             .try_into()?;
         Ok(certificate_value.with_hash_checked(hash)?)
     }
+
+    #[instrument(target = "grpc_client", skip_all, err, fields(address = self.address))]
+    async fn download_certificate(&mut self, hash: CryptoHash) -> Result<Certificate, NodeError> {
+        Ok(self
+            .client
+            .download_certificate(<CryptoHash as Into<api::CryptoHash>>::into(hash))
+            .await?
+            .into_inner()
+            .try_into()?)
+    }
 }
 
 #[cfg(not(web))]

linera-rpc/src/message.rs

@@ -7,7 +7,7 @@ use linera_base::{
     data_types::Blob,
     identifiers::{BlobId, ChainId},
 };
-use linera_chain::data_types::{BlockProposal, CertificateValue, LiteVote};
+use linera_chain::data_types::{BlockProposal, Certificate, CertificateValue, LiteVote};
 use linera_core::{
     data_types::{ChainInfoQuery, ChainInfoResponse, CrossChainRequest},
     node::NodeError,
@@ -27,6 +27,7 @@ pub enum RpcMessage {
     ChainInfoQuery(Box<ChainInfoQuery>),
     DownloadBlob(Box<BlobId>),
     DownloadCertificateValue(Box<CryptoHash>),
+    DownloadCertificate(Box<CryptoHash>),
     VersionInfoQuery,
 
     // Outbound
@@ -36,6 +37,7 @@ pub enum RpcMessage {
     VersionInfoResponse(Box<VersionInfo>),
     DownloadBlobResponse(Box<Blob>),
     DownloadCertificateValueResponse(Box<CertificateValue>),
+    DownloadCertificateResponse(Box<Certificate>),
 
     // Internal to a validator
     CrossChainRequest(Box<CrossChainRequest>),
@@ -62,7 +64,9 @@ impl RpcMessage {
             | DownloadBlob(_)
             | DownloadBlobResponse(_)
             | DownloadCertificateValue(_)
-            | DownloadCertificateValueResponse(_) => {
+            | DownloadCertificateValueResponse(_)
+            | DownloadCertificate(_)
+            | DownloadCertificateResponse(_) => {
                 return None;
             }
         };
@@ -76,7 +80,10 @@ impl RpcMessage {
         use RpcMessage::*;
 
         match self {
-            VersionInfoQuery | DownloadBlob(_) | DownloadCertificateValue(_) => true,
+            VersionInfoQuery
+            | DownloadBlob(_)
+            | DownloadCertificateValue(_)
+            | DownloadCertificate(_) => true,
             BlockProposal(_)
             | LiteCertificate(_)
             | Certificate(_)
@@ -87,7 +94,8 @@ impl RpcMessage {
             | ChainInfoResponse(_)
             | VersionInfoResponse(_)
             | DownloadBlobResponse(_)
-            | DownloadCertificateValueResponse(_) => false,
+            | DownloadCertificateValueResponse(_)
+            | DownloadCertificateResponse(_) => false,
         }
     }
 }
@@ -140,6 +148,18 @@ impl TryFrom<RpcMessage> for CertificateValue {
     }
 }
 
+impl TryFrom<RpcMessage> for Certificate {
+    type Error = NodeError;
+    fn try_from(message: RpcMessage) -> Result<Self, Self::Error> {
+        use RpcMessage::*;
+        match message {
+            DownloadCertificateResponse(certificate) => Ok(*certificate),
+            Error(error) => Err(*error),
+            _ => Err(NodeError::UnexpectedMessage),
+        }
+    }
+}
+
 impl From<BlockProposal> for RpcMessage {
     fn from(block_proposal: BlockProposal) -> Self {
         RpcMessage::BlockProposal(Box::new(block_proposal))
@@ -205,3 +225,9 @@ impl From<CertificateValue> for RpcMessage {
         RpcMessage::DownloadCertificateValueResponse(Box::new(certificate))
     }
 }
+
+impl From<Certificate> for RpcMessage {
+    fn from(certificate: Certificate) -> Self {
+        RpcMessage::DownloadCertificateResponse(Box::new(certificate))
+    }
+}

linera-rpc/src/simple/client.rs

@@ -151,6 +151,11 @@ impl ValidatorNode for SimpleClient {
             .await?;
         Ok(certificate_value.with_hash_checked(hash)?)
     }
+
+    async fn download_certificate(&mut self, hash: CryptoHash) -> Result<Certificate, NodeError> {
+        self.query(RpcMessage::DownloadCertificate(Box::new(hash)))
+            .await
+    }
 }
 
 #[derive(Clone)]

linera-rpc/src/simple/server.rs

@@ -301,7 +301,9 @@ where
             | RpcMessage::DownloadBlob(_)
             | RpcMessage::DownloadBlobResponse(_)
             | RpcMessage::DownloadCertificateValue(_)
-            | RpcMessage::DownloadCertificateValueResponse(_) => Err(NodeError::UnexpectedMessage),
+            | RpcMessage::DownloadCertificateValueResponse(_)
+            | RpcMessage::DownloadCertificate(_)
+            | RpcMessage::DownloadCertificateResponse(_) => Err(NodeError::UnexpectedMessage),
         };
 
         self.server.packets_processed += 1;

linera-rpc/tests/snapshots/format__format.yaml.snap

@@ -766,32 +766,40 @@ RpcMessage:
         NEWTYPE:
           TYPENAME: CryptoHash
     6:
-      VersionInfoQuery: UNIT
+      DownloadCertificate:
+        NEWTYPE:
+          TYPENAME: CryptoHash
     7:
+      VersionInfoQuery: UNIT
+    8:
       Vote:
         NEWTYPE:
           TYPENAME: LiteVote
-    8:
+    9:
       ChainInfoResponse:
         NEWTYPE:
           TYPENAME: ChainInfoResponse
-    9:
+    10:
       Error:
         NEWTYPE:
           TYPENAME: NodeError
-    10:
+    11:
       VersionInfoResponse:
         NEWTYPE:
           TYPENAME: VersionInfo
-    11:
+    12:
       DownloadBlobResponse:
         NEWTYPE:
           TYPENAME: Blob
-    12:
+    13:
       DownloadCertificateValueResponse:
         NEWTYPE:
           TYPENAME: CertificateValue
-    13:
+    14:
+      DownloadCertificateResponse:
+        NEWTYPE:
+          TYPENAME: Certificate
+    15:
       CrossChainRequest:
         NEWTYPE:
           TYPENAME: CrossChainRequest

linera-service/src/grpc_proxy.rs

@@ -27,8 +27,8 @@ use linera_rpc::{
             notifier_service_server::{NotifierService, NotifierServiceServer},
             validator_node_server::{ValidatorNode, ValidatorNodeServer},
             validator_worker_client::ValidatorWorkerClient,
-            Blob, BlobId, BlockProposal, CertificateValue, ChainInfoQuery, ChainInfoResult,
-            CryptoHash, HandleCertificateRequest, LiteCertificate, Notification,
+            Blob, BlobId, BlockProposal, Certificate, CertificateValue, ChainInfoQuery,
+            ChainInfoResult, CryptoHash, HandleCertificateRequest, LiteCertificate, Notification,
             SubscriptionRequest, VersionInfo,
         },
         pool::GrpcConnectionPool,
@@ -426,6 +426,21 @@ where
             .map_err(|err| Status::from_error(Box::new(err)))?;
         Ok(Response::new(certificate.try_into()?))
     }
+
+    #[instrument(skip_all, err(Display))]
+    async fn download_certificate(
+        &self,
+        request: Request<CryptoHash>,
+    ) -> Result<Response<Certificate>, Status> {
+        let hash = request.into_inner().try_into()?;
+        let certificate = self
+            .0
+            .storage
+            .read_certificate(hash)
+            .await
+            .map_err(|err| Status::from_error(Box::new(err)))?;
+        Ok(Response::new(certificate.try_into()?))
+    }
 }
 
 #[async_trait]

linera-service/src/proxy.rs

@@ -301,6 +301,9 @@ where
                     .into_inner()
                     .into(),
             )),
+            DownloadCertificate(hash) => {
+                Ok(Some(self.storage.read_certificate(*hash).await?.into()))
+            }
             BlockProposal(_)
             | LiteCertificate(_)
             | Certificate(_)
@@ -311,7 +314,8 @@ where
             | ChainInfoResponse(_)
             | VersionInfoResponse(_)
             | DownloadBlobResponse(_)
-            | DownloadCertificateValueResponse(_) => {
+            | DownloadCertificateValueResponse(_)
+            | DownloadCertificateResponse(_) => {
                 Err(anyhow::Error::from(NodeError::UnexpectedMessage))
             }
         }

linera-service/src/schema_export.rs

@@ -84,6 +84,10 @@ impl ValidatorNode for DummyValidatorNode {
     ) -> Result<HashedCertificateValue, NodeError> {
         Err(NodeError::UnexpectedMessage)
     }
+
+    async fn download_certificate(&mut self, _: CryptoHash) -> Result<Certificate, NodeError> {
+        Err(NodeError::UnexpectedMessage)
+    }
 }
 
 struct DummyValidatorNodeProvider;