Light client: further trait impls, improvements, and tests

tendermint/src/amino_types.rs

@@ -5,6 +5,7 @@
 
 pub mod block_id;
 pub mod ed25519;
+pub mod message;
 pub mod ping;
 pub mod proposal;
 pub mod remote_error;

tendermint/src/amino_types/block_id.rs

@@ -34,11 +34,11 @@ impl block::ParseId for BlockId {
 
 impl From<&block::Id> for BlockId {
     fn from(bid: &block::Id) -> Self {
-        let bid_hash = bid.hash.as_bytes().unwrap().to_vec();
-        match &bid.parts {
-            Some(parts) => BlockId::new(bid_hash, Some(PartsSetHeader::from(parts))),
-            None => BlockId::new(bid_hash, None),
-        }
+        let bid_hash = bid.hash.as_bytes();
+        BlockId::new(
+            bid_hash.to_vec(),
+            bid.parts.as_ref().map(PartsSetHeader::from),
+        )
     }
 }
 
@@ -89,7 +89,7 @@ impl PartsSetHeader {
 
 impl From<&parts::Header> for PartsSetHeader {
     fn from(parts: &parts::Header) -> Self {
-        PartsSetHeader::new(parts.total as i64, parts.hash.as_bytes().unwrap().to_vec())
+        PartsSetHeader::new(parts.total as i64, parts.hash.as_bytes().to_vec())
     }
 }
 

tendermint/src/amino_types/message.rs

@@ -0,0 +1,39 @@
+use prost_amino::encoding::encoded_len_varint;
+use std::convert::TryInto;
+
+/// Extend the original prost::Message trait with a few helper functions in order to
+/// reduce boiler-plate code (and without modifying the prost-amino dependency).
+pub trait AminoMessage: prost_amino::Message {
+    /// Directly amino encode a prost-amino message into a freshly created Vec<u8>.
+    /// This can be useful when passing those bytes directly to a hasher, or,
+    /// to reduce boiler plate code when working with the encoded bytes.
+    ///
+    /// Warning: Only use this method, if you are in control what will be encoded.
+    /// If there is an encoding error, this method will panic.
+    fn bytes_vec(&self) -> Vec<u8>
+    where
+        Self: Sized,
+    {
+        let mut res = Vec::with_capacity(self.encoded_len());
+        self.encode(&mut res).unwrap();
+        res
+    }
+
+    /// Encode prost-amino message as length delimited.
+    ///
+    /// Warning: Only use this method, if you are in control what will be encoded.
+    /// If there is an encoding error, this method will panic.
+    fn bytes_vec_length_delimited(&self) -> Vec<u8>
+    where
+        Self: Sized,
+    {
+        let len = self.encoded_len();
+        let mut res =
+            Vec::with_capacity(len + encoded_len_varint(len.try_into().expect("length overflow")));
+        self.encode_length_delimited(&mut res).unwrap();
+        res
+    }
+}
+impl<M: prost_amino::Message> AminoMessage for M {
+    // blanket impl
+}

tendermint/src/amino_types/vote.rs

@@ -11,7 +11,7 @@ use crate::{
     block::{self, ParseId},
     chain, consensus,
     error::Error,
-    vote, Hash,
+    vote,
 };
 use bytes::BufMut;
 use prost::{error::EncodeError, Message};
@@ -59,14 +59,8 @@ impl From<&vote::Vote> for Vote {
             height: vote.height.value() as i64, // TODO potential overflow :-/
             round: vote.round as i64,
             block_id: Some(BlockId {
-                hash: match vote.block_id.hash {
-                    Hash::Sha256(h) => h.to_vec(),
-                    _ => vec![],
-                },
-                parts_header: match &vote.block_id.parts {
-                    Some(parts) => Some(PartsSetHeader::from(parts)),
-                    None => None,
-                },
+                hash: vote.block_id.hash.as_bytes().to_vec(),
+                parts_header: vote.block_id.parts.as_ref().map(PartsSetHeader::from),
             }),
             timestamp: Some(TimeMsg::from(vote.timestamp)),
             validator_address: vote.validator_address.as_bytes().to_vec(),
@@ -246,9 +240,9 @@ impl ConsensusMessage for Vote {
 mod tests {
     use super::super::PartsSetHeader;
     use super::*;
+    use crate::amino_types::message::AminoMessage;
     use crate::amino_types::SignedMsgType;
     use chrono::{DateTime, Utc};
-    use prost::Message;
 
     #[test]
     fn test_vote_serialization() {
@@ -334,8 +328,7 @@ mod tests {
             vt_precommit.vote_type = SignedMsgType::PreCommit.to_u32(); // precommit
             println!("{:?}", vt_precommit);
             let cv_precommit = CanonicalVote::new(vt_precommit, "");
-            got = vec![];
-            cv_precommit.encode(&mut got).unwrap();
+            let got = AminoMessage::bytes_vec(&cv_precommit);
             let want = vec![
                 0x8,  // (field_number << 3) | wire_type
                 0x2,  // PrecommitType
@@ -356,10 +349,9 @@ mod tests {
             vt_prevote.round = 1;
             vt_prevote.vote_type = SignedMsgType::PreVote.to_u32();
 
-            got = vec![];
             let cv_prevote = CanonicalVote::new(vt_prevote, "");
 
-            cv_prevote.encode(&mut got).unwrap();
+            let got = AminoMessage::bytes_vec(&cv_prevote);
 
             let want = vec![
                 0x8,  // (field_number << 3) | wire_type
@@ -380,9 +372,8 @@ mod tests {
             vt_no_type.height = 1;
             vt_no_type.round = 1;
 
-            got = vec![];
             let cv = CanonicalVote::new(vt_no_type, "");
-            cv.encode(&mut got).unwrap();
+            let got = AminoMessage::bytes_vec(&cv);
 
             let want = vec![
                 0x11, // (field_number << 3) | wire_type
@@ -401,8 +392,7 @@ mod tests {
             no_vote_type2.round = 1;
 
             let with_chain_id = CanonicalVote::new(no_vote_type2, "test_chain_id");
-            got = vec![];
-            with_chain_id.encode(&mut got).unwrap();
+            got = AminoMessage::bytes_vec(&with_chain_id);
             let want = vec![
                 0x11, // (field_number << 3) | wire_type
                 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // height

tendermint/src/block.rs

@@ -9,15 +9,15 @@ pub mod parts;
 mod size;
 
 pub use self::{
-    commit::Commit,
-    header::Header,
+    commit::*,
+    header::{parse_non_empty_block_id, Header},
     height::*,
     id::{Id, ParseId},
     meta::Meta,
     size::Size,
 };
 use crate::{abci::transaction, evidence};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 
 /// Blocks consist of a header, transactions, votes (the commit), and a list of
 /// evidence of malfeasance (i.e. signing conflicting votes).
@@ -35,5 +35,28 @@ pub struct Block {
     pub evidence: evidence::Data,
 
     /// Last commit
-    pub last_commit: Commit,
+    #[serde(deserialize_with = "parse_non_empty_commit")]
+    pub last_commit: Option<Commit>,
+}
+
+pub(crate) fn parse_non_empty_commit<'de, D>(deserializer: D) -> Result<Option<Commit>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    #[derive(Deserialize)]
+    struct TmpCommit {
+        #[serde(deserialize_with = "parse_non_empty_block_id")]
+        block_id: Option<Id>,
+        precommits: Option<Precommits>,
+    }
+
+    let commit = TmpCommit::deserialize(deserializer)?;
+    if commit.block_id.is_none() || commit.precommits.is_none() {
+        Ok(None)
+    } else {
+        Ok(Some(Commit {
+            block_id: commit.block_id.unwrap(),
+            precommits: commit.precommits.unwrap(),
+        }))
+    }
 }

tendermint/src/block/commit.rs

@@ -19,31 +19,31 @@ pub struct Commit {
 
 /// Precommits which certify that a block is valid
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct Precommits(Option<Vec<Option<Vote>>>);
+pub struct Precommits(Vec<Option<Vote>>);
 
 impl Precommits {
     /// Create a new precommit collection
     pub fn new<I>(into_precommits: I) -> Self
     where
         I: Into<Vec<Option<Vote>>>,
     {
-        Self(Some(into_precommits.into()))
+        Self(into_precommits.into())
     }
 
     /// Convert this collection of precommits into a vector
     pub fn into_vec(self) -> Vec<Option<Vote>> {
-        self.iter().cloned().collect()
+        self.0.clone()
     }
 
     /// Iterate over the precommits in the collection
     pub fn iter(&self) -> slice::Iter<'_, Option<Vote>> {
-        self.as_ref().iter()
+        self.0.iter()
     }
 }
 
 impl AsRef<[Option<Vote>]> for Precommits {
     fn as_ref(&self) -> &[Option<Vote>] {
-        self.0.as_ref().map(Vec::as_slice).unwrap_or_else(|| &[])
+        self.0.as_slice()
     }
 }