Certificate handler methods work with generic certificate type. (#2921)

* Generalize functions to work on GenericCertificate

* RM HashedCertificateValue from value_cache_tests.rs

* Fix compilation

* HashedCertificateValue constructors map to new types

* Fix tests

* Use Either in full_certificate fn

* Replace Has with CertificateValueT

* Fix compilation under benchmark feature

* RM unnecessary trait bounds

* Fix name

* RM asyn_trait, replace with correct approach

* Pin it on me

* Fix tests

* clippy

* Update validators after submitting proposal.

* Rename inner to executed_block

* Reformat in usage of instrument macro

* RM unnecessary intermediate variables

* Fix comment

* s/CertificateProcessor/ProcessableCertificate/g

* fmt

* Return ConfirmedBlock value from Storage (#2950)

* Return ConfirmedBlock value from Storage

* s/read_hashed_certificate_value/read_hashed_confirmed_block/g

* RM unused TryFrom impl

* Simplify ValidatorNode API. (#2960)

* RM unused endpoint

* Fix field numbering in proto definitions

* download_certificate API returns ConfirmedBlockCertifiate

Author: deuszx

linera-chain/src/block.rs

@@ -4,14 +4,19 @@
 
 use std::fmt::Debug;
 
-use linera_base::{crypto::BcsHashable, data_types::BlockHeight, identifiers::ChainId};
+use linera_base::{
+    crypto::{BcsHashable, CryptoHash},
+    data_types::BlockHeight,
+    identifiers::ChainId,
+};
 use linera_execution::committee::Epoch;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use crate::{
     data_types::ExecutedBlock,
-    types::{CertificateValue, Has, Hashed, HashedCertificateValue},
+    types::{CertificateValue, Hashed, HashedCertificateValue},
+    ChainError,
 };
 
 /// Wrapper around an `ExecutedBlock` that has been validated.
@@ -35,21 +40,13 @@ impl ValidatedBlock {
     pub fn into_inner(self) -> ExecutedBlock {
         self.executed_block
     }
-}
-
-impl BcsHashable for ValidatedBlock {}
 
-impl Has<ChainId> for ValidatedBlock {
-    fn get(&self) -> &ChainId {
-        &self.executed_block.block.chain_id
+    pub fn to_log_str(&self) -> &'static str {
+        "validated_block"
     }
 }
 
-impl From<ValidatedBlock> for HashedCertificateValue {
-    fn from(value: ValidatedBlock) -> Self {
-        HashedCertificateValue::new_validated(value.executed_block)
-    }
-}
+impl BcsHashable for ValidatedBlock {}
 
 impl TryFrom<HashedCertificateValue> for Hashed<ValidatedBlock> {
     type Error = ConversionError;
@@ -72,9 +69,28 @@ pub struct ConfirmedBlock {
     executed_block: ExecutedBlock,
 }
 
-impl From<ConfirmedBlock> for HashedCertificateValue {
-    fn from(value: ConfirmedBlock) -> Self {
-        HashedCertificateValue::new_confirmed(value.executed_block)
+#[async_graphql::Object(cache_control(no_cache))]
+impl ConfirmedBlock {
+    #[graphql(derived(name = "executed_block"))]
+    async fn _executed_block(&self) -> ExecutedBlock {
+        self.executed_block.clone()
+    }
+
+    async fn status(&self) -> String {
+        "confirmed".to_string()
+    }
+}
+
+#[async_graphql::Object(cache_control(no_cache), name_type)]
+impl Hashed<ConfirmedBlock> {
+    #[graphql(derived(name = "hash"))]
+    async fn _hash(&self) -> CryptoHash {
+        self.hash()
+    }
+
+    #[graphql(derived(name = "value"))]
+    async fn _value(&self) -> ConfirmedBlock {
+        self.inner().clone()
     }
 }
 
@@ -115,19 +131,40 @@ impl ConfirmedBlock {
     }
 
     /// Returns a reference to the `ExecutedBlock` contained in this `ConfirmedBlock`.
-    pub fn inner(&self) -> &ExecutedBlock {
+    pub fn executed_block(&self) -> &ExecutedBlock {
         &self.executed_block
     }
 
     /// Consumes this `ConfirmedBlock`, returning the `ExecutedBlock` it contains.
     pub fn into_inner(self) -> ExecutedBlock {
         self.executed_block
     }
-}
 
-impl Has<ChainId> for ConfirmedBlock {
-    fn get(&self) -> &ChainId {
-        &self.executed_block.block.chain_id
+    pub fn to_log_str(&self) -> &'static str {
+        "confirmed_block"
+    }
+
+    /// Creates a `HashedCertificateValue` without checking that this is the correct hash!
+    pub fn with_hash_unchecked(self, hash: CryptoHash) -> Hashed<ConfirmedBlock> {
+        Hashed::unchecked_new(self, hash)
+    }
+
+    fn with_hash(self) -> Hashed<Self> {
+        let hash = CryptoHash::new(&self);
+        Hashed::unchecked_new(self, hash)
+    }
+
+    /// Creates a `HashedCertificateValue` checking that this is the correct hash.
+    pub fn with_hash_checked(self, hash: CryptoHash) -> Result<Hashed<ConfirmedBlock>, ChainError> {
+        let hashed_certificate_value = self.with_hash();
+        if hashed_certificate_value.hash() == hash {
+            Ok(hashed_certificate_value)
+        } else {
+            Err(ChainError::CertificateValueHashMismatch {
+                expected: hash,
+                actual: hashed_certificate_value.hash(),
+            })
+        }
     }
 }
 
@@ -146,11 +183,9 @@ impl Timeout {
             epoch,
         }
     }
-}
 
-impl From<Timeout> for HashedCertificateValue {
-    fn from(value: Timeout) -> Self {
-        HashedCertificateValue::new_timeout(value.chain_id, value.height, value.epoch)
+    pub fn to_log_str(&self) -> &'static str {
+        "timeout"
     }
 }
 
@@ -167,12 +202,6 @@ impl TryFrom<HashedCertificateValue> for Hashed<Timeout> {
 
 impl BcsHashable for Timeout {}
 
-impl Has<ChainId> for Timeout {
-    fn get(&self) -> &ChainId {
-        &self.chain_id
-    }
-}
-
 /// Failure to convert a [`HashedCertificateValue`] into one of the block types.
 #[derive(Clone, Copy, Debug, Error)]
 pub enum ConversionError {

linera-chain/src/certificate/confirmed.rs

@@ -10,7 +10,7 @@ use super::{
     HashedCertificateValue,
 };
 use crate::{
-    block::{ConfirmedBlock, ValidatedBlock},
+    block::{ConfirmedBlock, ConversionError, ValidatedBlock},
     data_types::{ExecutedBlock, Medium, MessageBundle},
 };
 
@@ -29,7 +29,7 @@ impl GenericCertificate<ConfirmedBlock> {
 
     /// Returns reference to the `ExecutedBlock` contained in this certificate.
     pub fn executed_block(&self) -> &ExecutedBlock {
-        self.inner().inner()
+        self.inner().executed_block()
     }
 
     /// Returns whether this value contains the message with the specified ID.
@@ -57,7 +57,7 @@ impl GenericCertificate<ConfirmedBlock> {
 }
 
 impl TryFrom<Certificate> for GenericCertificate<ConfirmedBlock> {
-    type Error = &'static str;
+    type Error = ConversionError;
 
     fn try_from(cert: Certificate) -> Result<Self, Self::Error> {
         let hash = cert.hash();
@@ -68,18 +68,17 @@ impl TryFrom<Certificate> for GenericCertificate<ConfirmedBlock> {
                 round,
                 signatures,
             )),
-            _ => Err("Expected a confirmed block certificate"),
+            _ => Err(ConversionError::ConfirmedBlock),
         }
     }
 }
 
 impl From<GenericCertificate<ConfirmedBlock>> for Certificate {
     fn from(cert: GenericCertificate<ConfirmedBlock>) -> Certificate {
         let (value, round, signatures) = cert.destructure();
-        Certificate::new(
-            HashedCertificateValue::new_confirmed(value.into_inner().into_inner()),
-            round,
-            signatures,
-        )
+        let hash = value.hash();
+        let value =
+            Hashed::unchecked_new(CertificateValue::ConfirmedBlock(value.into_inner()), hash);
+        Certificate::new(value, round, signatures)
     }
 }

linera-chain/src/certificate/generic.rs

@@ -9,7 +9,7 @@ use linera_base::{
 };
 use linera_execution::committee::{Committee, ValidatorName};
 
-use super::hashed::Hashed;
+use super::{hashed::Hashed, CertificateValueT};
 use crate::ChainError;
 
 /// Generic type representing a certificate for `value` of type `T`.
@@ -99,6 +99,18 @@ impl<T> GenericCertificate<T> {
         crate::data_types::check_signatures(self.hash(), self.round, &self.signatures, committee)?;
         Ok(())
     }
+
+    pub fn lite_certificate(&self) -> crate::certificate::LiteCertificate<'_>
+    where
+        T: CertificateValueT,
+    {
+        let value = self.value.lite();
+        crate::certificate::LiteCertificate {
+            value,
+            round: self.round,
+            signatures: std::borrow::Cow::Borrowed(&self.signatures),
+        }
+    }
 }
 
 impl<T: Clone> Clone for GenericCertificate<T> {

linera-chain/src/certificate/hashed.rs

@@ -2,13 +2,13 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::borrow::Cow;
+
 use custom_debug_derive::Debug;
-use linera_base::{
-    crypto::{BcsHashable, CryptoHash},
-    identifiers::ChainId,
-};
+use linera_base::crypto::{BcsHashable, CryptoHash};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
+use super::CertificateValueT;
 use crate::data_types::LiteValue;
 
 /// Wrapper type around hashed instance of `T` type.
@@ -55,11 +55,11 @@ impl<T> Hashed<T> {
 
     pub fn lite(&self) -> LiteValue
     where
-        T: Has<ChainId>,
+        T: CertificateValueT,
     {
         LiteValue {
             value_hash: self.hash,
-            chain_id: *self.value.get(),
+            chain_id: self.value.chain_id(),
         }
     }
 }
@@ -91,6 +91,12 @@ impl<T: Clone> Clone for Hashed<T> {
     }
 }
 
+impl<T: async_graphql::OutputType> async_graphql::TypeName for Hashed<T> {
+    fn type_name() -> Cow<'static, str> {
+        format!("Hashed{}", T::type_name(),).into()
+    }
+}
+
 #[cfg(with_testing)]
 impl<T> PartialEq for Hashed<T> {
     fn eq(&self, other: &Self) -> bool {
@@ -100,8 +106,3 @@ impl<T> PartialEq for Hashed<T> {
 
 #[cfg(with_testing)]
 impl<T> Eq for Hashed<T> {}
-
-/// A constraint summing a value of type `T`.
-pub trait Has<T> {
-    fn get(&self) -> &T;
-}

linera-chain/src/certificate/lite.rs

@@ -4,11 +4,11 @@
 
 use std::borrow::Cow;
 
-use linera_base::{crypto::Signature, data_types::Round, identifiers::ChainId};
+use linera_base::{crypto::Signature, data_types::Round};
 use linera_execution::committee::{Committee, ValidatorName};
 use serde::{Deserialize, Serialize};
 
-use super::{GenericCertificate, Has, Hashed};
+use super::{CertificateValueT, GenericCertificate, Hashed};
 use crate::{
     data_types::{check_signatures, LiteValue, LiteVote},
     ChainError,
@@ -74,8 +74,12 @@ impl<'a> LiteCertificate<'a> {
     }
 
     /// Returns the [`GenericCertificate`] with the specified value, if it matches.
-    pub fn with_value<T: Has<ChainId>>(self, value: Hashed<T>) -> Option<GenericCertificate<T>> {
-        if &self.value.chain_id != value.inner().get() || self.value.value_hash != value.hash() {
+    pub fn with_value<T: CertificateValueT>(
+        self,
+        value: Hashed<T>,
+    ) -> Option<GenericCertificate<T>> {
+        if self.value.chain_id != value.inner().chain_id() || self.value.value_hash != value.hash()
+        {
             return None;
         }
         Some(GenericCertificate::new(