Light client: trait impls

tendermint/src/amino_types.rs

@@ -12,6 +12,7 @@ pub mod secret_connection;
 pub mod signature;
 pub mod time;
 pub mod validate;
+pub mod version;
 pub mod vote;
 
 pub use self::{
@@ -24,5 +25,6 @@ pub use self::{
     signature::{SignableMsg, SignedMsgType},
     time::TimeMsg,
     validate::ConsensusMessage,
+    version::ConsensusVersion,
     vote::{SignVoteRequest, SignedVoteResponse, AMINO_NAME as VOTE_AMINO_NAME},
 };

tendermint/src/amino_types/block_id.rs

@@ -1,4 +1,5 @@
 use super::validate::{ConsensusMessage, ValidationError, ValidationErrorKind::*};
+use crate::block::parts;
 use crate::{
     block,
     error::Error,
@@ -14,6 +15,12 @@ pub struct BlockId {
     pub parts_header: Option<PartsSetHeader>,
 }
 
+impl BlockId {
+    pub fn new(hash: Vec<u8>, parts_header: Option<PartsSetHeader>) -> Self {
+        BlockId { hash, parts_header }
+    }
+}
+
 impl block::ParseId for BlockId {
     fn parse_block_id(&self) -> Result<block::Id, Error> {
         let hash = Hash::new(hash::Algorithm::Sha256, &self.hash)?;
@@ -25,6 +32,16 @@ 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),
+        }
+    }
+}
+
 impl ConsensusMessage for BlockId {
     fn validate_basic(&self) -> Result<(), ValidationError> {
         // Hash can be empty in case of POLBlockID in Proposal.
@@ -64,6 +81,18 @@ pub struct PartsSetHeader {
     pub hash: Vec<u8>,
 }
 
+impl PartsSetHeader {
+    pub fn new(total: i64, hash: Vec<u8>) -> Self {
+        PartsSetHeader { total, hash }
+    }
+}
+
+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())
+    }
+}
+
 impl PartsSetHeader {
     fn parse_parts_header(&self) -> Option<block::parts::Header> {
         Hash::new(hash::Algorithm::Sha256, &self.hash)

tendermint/src/amino_types/version.rs

@@ -0,0 +1,21 @@
+use crate::block::*;
+
+#[derive(Clone, Message)]
+pub struct ConsensusVersion {
+    /// Block version
+    #[prost(uint64, tag = "1")]
+    pub block: u64,
+
+    /// App version
+    #[prost(uint64, tag = "2")]
+    pub app: u64,
+}
+
+impl From<&header::Version> for ConsensusVersion {
+    fn from(version: &header::Version) -> Self {
+        ConsensusVersion {
+            block: version.block,
+            app: version.app,
+        }
+    }
+}

tendermint/src/amino_types/vote.rs

@@ -6,10 +6,12 @@ use super::{
     validate::{ConsensusMessage, ValidationError, ValidationErrorKind::*},
     SignedMsgType,
 };
+use crate::amino_types::PartsSetHeader;
 use crate::{
     block::{self, ParseId},
     chain, consensus,
     error::Error,
+    vote, Hash,
 };
 use bytes::BufMut;
 use prost::{error::EncodeError, Message};
@@ -49,6 +51,30 @@ impl Vote {
     }
 }
 
+impl From<&vote::Vote> for Vote {
+    fn from(vote: &vote::Vote) -> Self {
+        Vote {
+            vote_type: vote.vote_type.to_u32(),
+            height: vote.height.value() as i64, // TODO potential overflow :-/
+            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,
+                },
+            }),
+            round: vote.round as i64,
+            timestamp: Some(TimeMsg::from(vote.timestamp)),
+            validator_address: vote.validator_address.as_bytes().to_vec(),
+            validator_index: vote.validator_index as i64, // TODO potential overflow :-/
+            signature: vote.signature.as_bytes().to_vec(),
+        }
+    }
+}
+
 impl block::ParseHeight for Vote {
     fn parse_block_height(&self) -> Result<block::Height, Error> {
         block::Height::try_from_i64(self.height)
@@ -102,7 +128,7 @@ impl block::ParseHeight for CanonicalVote {
 }
 
 impl CanonicalVote {
-    fn new(vote: Vote, chain_id: &str) -> CanonicalVote {
+    pub fn new(vote: Vote, chain_id: &str) -> CanonicalVote {
         CanonicalVote {
             vote_type: vote.vote_type,
             chain_id: chain_id.to_string(),

tendermint/src/block/header.rs

@@ -1,5 +1,7 @@
 //! Block headers
-use crate::{account, block, chain, lite, Hash, Time};
+use crate::merkle::simple_hash_from_byte_slices;
+use crate::{account, amino_types, block, chain, lite, Hash, Time};
+use prost::Message;
 use {
     crate::serializers,
     serde::{Deserialize, Serialize},
@@ -83,11 +85,89 @@ impl lite::Header for Header {
     }
 
     fn next_validators_hash(&self) -> Hash {
-        unimplemented!()
+        self.next_validators_hash
     }
 
     fn hash(&self) -> Hash {
-        unimplemented!()
+        let mut version_enc = vec![];
+        // TODO: 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 mut height_enc = vec![];
+        prost_amino::encoding::encode_varint(self.height.value(), &mut height_enc);
+        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 = encode_bytes(&chain_id_bytes);
+        let mut num_tx_enc = vec![];
+        prost_amino::encoding::encode_varint(self.num_txs, &mut num_tx_enc);
+        let mut total_tx_enc = vec![];
+        prost_amino::encoding::encode_varint(self.total_txs, &mut total_tx_enc);
+        let mut last_block_id_enc = vec![];
+        amino_types::BlockId::from(&self.last_block_id)
+            .encode(&mut last_block_id_enc)
+            .unwrap();
+        let mut last_commit_hash_enc = vec![];
+        if let Some(last_commit_hash_bytes) = self.last_commit_hash.as_bytes() {
+            last_commit_hash_enc = encode_bytes(last_commit_hash_bytes);
+        }
+        let mut data_hash_enc = vec![];
+        if let Some(data_hash_bytes) = self.data_hash.as_bytes() {
+            data_hash_enc = encode_bytes(data_hash_bytes);
+        }
+        let mut validator_hash_enc = vec![];
+        if let Some(validator_hash_bytes) = self.validators_hash.as_bytes() {
+            validator_hash_enc = encode_bytes(validator_hash_bytes);
+        }
+        let mut next_validator_hash_enc = vec![];
+        if let Some(next_validator_hash_bytes) = self.next_validators_hash.as_bytes() {
+            next_validator_hash_enc = encode_bytes(next_validator_hash_bytes);
+        }
+        let mut consensus_hash_enc = vec![];
+        if let Some(consensus_hash_bytes) = self.consensus_hash.as_bytes() {
+            consensus_hash_enc = encode_bytes(consensus_hash_bytes);
+        }
+        let mut app_hash_enc = vec![];
+        if let Some(app_hash_bytes) = self.app_hash.as_bytes() {
+            app_hash_enc = encode_bytes(app_hash_bytes);
+        }
+        let mut last_result_hash_enc = vec![];
+        if let Some(last_result_hash_bytes) = self.last_results_hash.as_bytes() {
+            last_result_hash_enc = encode_bytes(last_result_hash_bytes);
+        }
+        let mut evidence_hash_enc = vec![];
+        if let Some(evidence_hash_bytes) = self.evidence_hash.as_bytes() {
+            evidence_hash_enc = encode_bytes(evidence_hash_bytes);
+        }
+        let proposer_address_bytes = self.proposer_address.as_bytes();
+        let proposer_address_enc = encode_bytes(&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()))
     }
 }
 
@@ -111,3 +191,10 @@ pub struct Version {
     )]
     pub app: u64,
 }
+
+fn encode_bytes(bytes: &[u8]) -> Vec<u8> {
+    let mut chain_id_enc = vec![];
+    prost_amino::encode_length_delimiter(bytes.len(), &mut chain_id_enc).unwrap();
+    chain_id_enc.append(&mut bytes.to_vec());
+    chain_id_enc
+}

tendermint/src/chain/id.rs

@@ -30,6 +30,11 @@ impl Id {
         // so in theory this should never panic
         str::from_utf8(byte_slice).unwrap()
     }
+
+    /// Get the chain ID as a raw bytes.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.as_str().as_bytes()
+    }
 }
 
 impl AsRef<str> for Id {

tendermint/src/lite.rs

@@ -1,4 +1,5 @@
-pub use self::types::*;
 pub mod types;
 pub mod verifier;
+
+pub use self::types::*;
 pub use self::verifier::*;

tendermint/src/lite/types.rs

@@ -6,6 +6,7 @@ use crate::block::Height;
 use crate::Hash;
 #[allow(clippy::all)]
 use crate::Time;
+use bytes::BufMut;
 
 /// TrustedState stores the latest state trusted by a lite client,
 /// including the last header and the validator set to use to verify
@@ -81,6 +82,8 @@ pub trait Commit {
     /// we ignore absent votes and votes for nil here.
     /// NOTE: we may want to check signatures for nil votes,
     /// and thus use an ternary enum here instead of the binary Option.
+    // TODO figure out if we want/can do an iter() method here that returns a
+    // VoteIterator instead of returning a vec
     fn into_vec(&self) -> Vec<Option<Self::Vote>>;
 }
 
@@ -96,7 +99,9 @@ pub trait Commit {
 /// is only necessary to avoid slashing in the multi chain context.
 pub trait Vote {
     fn validator_id(&self) -> Id;
-    fn sign_bytes(&self) -> &[u8];
+    fn sign_bytes<B>(&self, sign_bytes: &mut B)
+    where
+        B: BufMut;
     fn signature(&self) -> &[u8];
 }
 

tendermint/src/lite/verifier.rs

@@ -127,7 +127,9 @@ where
         };
 
         // check vote is valid from validator
-        if !val.verify_signature(vote.sign_bytes(), vote.signature()) {
+        let mut sign_bytes = vec![];
+        vote.sign_bytes(&mut sign_bytes);
+        if !val.verify_signature(&sign_bytes, vote.signature()) {
             return Err(Error::InvalidSignature);
         }
         signed_power += val.power();
@@ -176,7 +178,9 @@ where
         };
 
         // check vote is valid from validator
-        if !val.verify_signature(vote.sign_bytes(), vote.signature()) {
+        let mut sign_bytes = vec![];
+        vote.sign_bytes(&mut sign_bytes);
+        if !val.verify_signature(&sign_bytes, vote.signature()) {
             return Err(Error::InvalidSignature);
         }
         signed_power += val.power();

tendermint/src/signature.rs

@@ -18,6 +18,13 @@ impl Signature {
             Signature::Ed25519(_) => Algorithm::Ed25519,
         }
     }
+
+    /// Return the raw bytes of this signature
+    pub fn as_bytes(&self) -> &[u8] {
+        match self {
+            Signature::Ed25519(sig) => sig.as_bytes(),
+        }
+    }
 }
 
 impl<'de> Deserialize<'de> for Signature {