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/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/proposal.rs

@@ -1,4 +1,3 @@
-use std::convert::TryFrom;
 use super::{
     block_id::{BlockId, CanonicalBlockId, CanonicalPartSetHeader},
     remote_error::RemoteError,
@@ -14,6 +13,7 @@ use crate::{
 use bytes::BufMut;
 use prost::{EncodeError, Message};
 use signatory::{ed25519, Signature};
+use std::convert::TryFrom;
 
 #[derive(Clone, PartialEq, Message)]
 pub struct Proposal {

tendermint/src/amino_types/vote.rs

@@ -1,4 +1,3 @@
-use std::convert::TryFrom;
 use super::{
     block_id::{BlockId, CanonicalBlockId, CanonicalPartSetHeader},
     remote_error::RemoteError,
@@ -17,6 +16,7 @@ use crate::{
 use bytes::BufMut;
 use prost::{error::EncodeError, Message};
 use signatory::{ed25519, Signature};
+use std::convert::TryFrom;
 
 const VALIDATOR_ADDR_SIZE: usize = 20;
 
@@ -78,7 +78,7 @@ impl From<&vote::Vote> for Vote {
 
 impl block::ParseHeight for Vote {
     fn parse_block_height(&self) -> Result<block::Height, Error> {
-        block::Height::try_from(self.height)
+        block::Height::try_from_i64(self.height)
     }
 }
 
@@ -124,7 +124,7 @@ impl chain::ParseId for CanonicalVote {
 
 impl block::ParseHeight for CanonicalVote {
     fn parse_block_height(&self) -> Result<block::Height, Error> {
-        block::Height::try_from(self.height)
+        block::Height::try_from_i64(self.height)
     }
 }
 
@@ -189,7 +189,7 @@ impl SignableMsg for SignVoteRequest {
     fn consensus_state(&self) -> Option<consensus::State> {
         match self.vote {
             Some(ref v) => Some(consensus::State {
-                height: match block::Height::try_from(v.height) {
+                height: match block::Height::try_from_i64(v.height) {
                     Ok(h) => h,
                     Err(_err) => return None, // TODO(tarcieri): return an error?
                 },
@@ -246,9 +246,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 +334,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 +355,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 +378,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 +398,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/header.rs

@@ -1,7 +1,10 @@
 //! Block headers
+use amino_types::{message::AminoMessage, BlockId, ConsensusVersion, TimeMsg};
+use serde::{de::Error as _, Deserialize, Deserializer, Serialize};
+use std::str::FromStr;
+
 use crate::merkle::simple_hash_from_byte_slices;
-use crate::{account, amino_types, block, chain, lite, Hash, Time};
-use prost::Message;
+use crate::{account, amino_types, block, chain, lite, serializers, Hash, Time};
 use {
     crate::serializers,
     serde::{Deserialize, Serialize},
@@ -41,13 +44,16 @@ pub struct Header {
     pub total_txs: u64,
 
     /// Previous block info
-    pub last_block_id: block::Id,
+    #[serde(deserialize_with = "parse_non_empty_block_id")]
+    pub last_block_id: Option<block::Id>,
 
     /// Commit from validators from the last block
-    pub last_commit_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub last_commit_hash: Option<Hash>,
 
     /// Merkle root of transaction hashes
-    pub data_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub data_hash: Option<Hash>,
 
     /// Validators for the current block
     pub validators_hash: Hash,
@@ -59,13 +65,16 @@ pub struct Header {
     pub consensus_hash: Hash,
 
     /// State after txs from the previous block
-    pub app_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub app_hash: Option<Hash>,
 
     /// Root hash of all results from the txs from the previous block
-    pub last_results_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub last_results_hash: Option<Hash>,
 
     /// Hash of evidence included in the block
-    pub evidence_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub evidence_hash: Option<Hash>,
 
     /// Original proposer of the block
     pub proposer_address: account::Id,
@@ -89,58 +98,36 @@ impl lite::Header for Header {
     }
 
     fn hash(&self) -> Hash {
-        let mut version_enc = vec![];
-        // TODO: if there is an encoding problem this will
+        // Note that if there is an encoding problem this will
         // panic (as the golang code would):
         // https://github.com/tendermint/tendermint/blob/134fe2896275bb926b49743c1e25493f6b24cc31/types/block.go#L393
         // https://github.com/tendermint/tendermint/blob/134fe2896275bb926b49743c1e25493f6b24cc31/types/encoding_helper.go#L9:6
-        // Instead, handle errors gracefully here.
-        amino_types::ConsensusVersion::from(&self.version)
-            .encode(&mut version_enc)
-            .unwrap();
-        let height_enc = encode_varint(self.height.value());
-        let mut time_enc = vec![];
-        amino_types::TimeMsg::from(self.time)
-            .encode(&mut time_enc)
-            .unwrap();
-        let chain_id_bytes = self.chain_id.as_bytes();
-        let chain_id_enc = bytes_enc(&chain_id_bytes);
-        let num_tx_enc = encode_varint(self.num_txs);
-        let total_tx_enc = encode_varint(self.total_txs);
-        let mut last_block_id_enc = vec![];
-        amino_types::BlockId::from(&self.last_block_id)
-            .encode(&mut last_block_id_enc)
-            .unwrap();
-        let last_commit_hash_enc = encode_hash(self.last_commit_hash);
-        let data_hash_enc = encode_hash(self.data_hash);
-        let validator_hash_enc = encode_hash(self.validators_hash);
-        let next_validator_hash_enc = encode_hash(self.next_validators_hash);
-        let consensus_hash_enc = encode_hash(self.consensus_hash);
-        let app_hash_enc = encode_hash(self.app_hash);
-        let last_result_hash_enc = encode_hash(self.last_results_hash);
-        let evidence_hash_enc = encode_hash(self.evidence_hash);
-        let proposer_address_bytes = self.proposer_address.as_bytes();
-        let proposer_address_enc = bytes_enc(&proposer_address_bytes);
-
-        let mut byteslices: Vec<&[u8]> = vec![];
-        byteslices.push(version_enc.as_slice());
-        byteslices.push(chain_id_enc.as_slice());
-        byteslices.push(height_enc.as_slice());
-        byteslices.push(time_enc.as_slice());
-        byteslices.push(num_tx_enc.as_slice());
-        byteslices.push(total_tx_enc.as_slice());
-        byteslices.push(last_block_id_enc.as_slice());
-        byteslices.push(last_commit_hash_enc.as_slice());
-        byteslices.push(data_hash_enc.as_slice());
-        byteslices.push(validator_hash_enc.as_slice());
-        byteslices.push(next_validator_hash_enc.as_slice());
-        byteslices.push(consensus_hash_enc.as_slice());
-        byteslices.push(app_hash_enc.as_slice());
-        byteslices.push(last_result_hash_enc.as_slice());
-        byteslices.push(evidence_hash_enc.as_slice());
-        byteslices.push(proposer_address_enc.as_slice());
-
-        Hash::Sha256(simple_hash_from_byte_slices(byteslices.as_slice()))
+
+        let mut byteslices: Vec<Vec<u8>> = Vec::with_capacity(16);
+        byteslices.push(AminoMessage::bytes_vec(&ConsensusVersion::from(
+            &self.version,
+        )));
+        byteslices.push(bytes_enc(self.chain_id.as_bytes()));
+        byteslices.push(encode_varint(self.height.value()));
+        byteslices.push(AminoMessage::bytes_vec(&TimeMsg::from(self.time)));
+        byteslices.push(encode_varint(self.num_txs));
+        byteslices.push(encode_varint(self.total_txs));
+        byteslices.push(
+            self.last_block_id
+                .as_ref()
+                .map_or(vec![], |id| AminoMessage::bytes_vec(&BlockId::from(id))),
+        );
+        byteslices.push(self.last_commit_hash.as_ref().map_or(vec![], encode_hash));
+        byteslices.push(self.data_hash.as_ref().map_or(vec![], encode_hash));
+        byteslices.push(encode_hash(&self.validators_hash));
+        byteslices.push(encode_hash(&self.next_validators_hash));
+        byteslices.push(encode_hash(&self.consensus_hash));
+        byteslices.push(self.app_hash.as_ref().map_or(vec![], encode_hash));
+        byteslices.push(self.last_results_hash.as_ref().map_or(vec![], encode_hash));
+        byteslices.push(self.evidence_hash.as_ref().map_or(vec![], encode_hash));
+        byteslices.push(bytes_enc(self.proposer_address.as_bytes()));
+
+        Hash::Sha256(simple_hash_from_byte_slices(byteslices))
     }
 }
 
@@ -166,10 +153,10 @@ pub struct Version {
 }
 
 fn bytes_enc(bytes: &[u8]) -> Vec<u8> {
-    let mut chain_id_enc = vec![];
+    let mut res = vec![];
     prost_amino::encode_length_delimiter(bytes.len(), &mut chain_id_enc).unwrap();
-    chain_id_enc.append(&mut bytes.to_vec());
-    chain_id_enc
+    res.append(&mut bytes.to_vec());
+    res
 }
 
 fn encode_hash(hash: Hash) -> Vec<u8> {

tendermint/src/block/height.rs

@@ -8,7 +8,7 @@ use std::{
 
 /// Block height for a particular chain (i.e. number of blocks created since
 /// the chain began)
-/// 
+///
 /// A height of 0 represents a chain which has not yet produced a block.
 #[derive(Copy, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct Height(pub u64);

tendermint/src/block/id.rs

@@ -84,7 +84,7 @@ mod tests {
     fn parses_hex_strings() {
         let id = Id::from_str(EXAMPLE_SHA256_ID).unwrap();
         assert_eq!(
-            id.hash.as_bytes().unwrap(),
+            id.hash.as_bytes(),
             b"\x26\xC0\xA4\x1F\x32\x43\xC6\xBC\xD7\xAD\x2D\xFF\x8A\x8D\x83\xA7\
               \x1D\x29\xD3\x07\xB5\x32\x6C\x22\x7F\x73\x4A\x1A\x51\x2F\xE4\x7D"
                 .as_ref()

tendermint/src/genesis.rs

@@ -1,6 +1,6 @@
 //! Genesis data
 
-use crate::{chain, consensus, validator, Hash, Time};
+use crate::{chain, consensus, serializers, validator, Hash, Time};
 use serde::{Deserialize, Serialize};
 
 /// Genesis data
@@ -19,7 +19,8 @@ pub struct Genesis<AppState = serde_json::Value> {
     pub validators: Vec<validator::Info>,
 
     /// App hash
-    pub app_hash: Hash,
+    #[serde(deserialize_with = "serializers::parse_non_empty_hash")]
+    pub app_hash: Option<Hash>,
 
     /// App state
     pub app_state: AppState,