temp

Author: HoOngEe

core/src/consensus/sortition/mod.rs

@@ -27,16 +27,65 @@ use primitives::H256;
 use vrf::openssl::Error as VrfError;
 
 use self::vrf_sortition::{PriorityInfo, VRFSortition};
+use crate::consensus::{Height, View};
 
-pub type VRFSeed = H256;
+#[derive(Debug, PartialEq, Clone, Copy, RlpEncodable, RlpDecodable)]
+pub struct VRFSeed(H256);
 
-#[derive(Debug, PartialEq, RlpEncodable, RlpDecodable)]
+impl AsRef<[u8]> for VRFSeed {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl ::core::ops::Deref for VRFSeed {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl From<H256> for VRFSeed {
+    fn from(hash: H256) -> Self {
+        VRFSeed(hash)
+    }
+}
+
+#[cfg(test)]
+impl From<u64> for VRFSeed {
+    fn from(mut value: u64) -> Self {
+        let hash: H256 = value.into();
+        hash.into()
+    }
+}
+
+impl VRFSeed {
+    pub fn zero() -> Self {
+        VRFSeed(H256::zero())
+    }
+}
+
+impl VRFSeed {
+    /// Calculate the common message used in next seed generation.
+    pub fn generate_next_msg(&self, height: Height, view: View) -> Vec<u8> {
+        [&self[..], &height.to_be_bytes(), &view.to_be_bytes()].concat()
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, RlpEncodable, RlpDecodable)]
 pub struct PriorityMessage {
     pub seed: VRFSeed,
     pub info: PriorityInfo,
 }
 
 impl PriorityMessage {
+    pub fn seed(&self) -> VRFSeed {
+        self.seed
+    }
+
     pub fn verify(
         &self,
         signer_public: &Public,
@@ -80,7 +129,7 @@ mod priority_message_tests {
             sortition_scheme.create_highest_priority_info(seed, priv_key, voting_power).unwrap().unwrap();
 
         let priority_message = PriorityMessage {
-            seed,
+            seed: seed.into(),
             info: priority_info,
         };
         assert!(priority_message.verify(&pub_key, voting_power, &sortition_scheme).unwrap());
@@ -104,7 +153,7 @@ mod priority_message_tests {
             sortition_scheme.create_highest_priority_info(seed, priv_key, voting_power).unwrap().unwrap();
 
         let priority_message = PriorityMessage {
-            seed,
+            seed: seed.into(),
             info: priority_info,
         };
         rlp_encode_and_decode_test!(priority_message);

core/src/consensus/tendermint/message.rs

@@ -113,6 +113,7 @@ pub enum TendermintMessage {
     ProposalBlock {
         signature: SchnorrSignature,
         view: View,
+        priority: PriorityMessage,
         message: Bytes,
     },
     StepState {
@@ -149,12 +150,15 @@ impl Encodable for TendermintMessage {
             TendermintMessage::ProposalBlock {
                 signature,
                 view,
+                priority,
                 message,
             } => {
                 s.begin_list(4);
                 s.append(&MESSAGE_ID_PROPOSAL_BLOCK);
                 s.append(signature);
                 s.append(view);
+                // FIXME: Consider compressing
+                s.append(priority);
 
                 let compressed = {
                     // TODO: Cache the Encoder object
@@ -238,15 +242,16 @@ impl Decodable for TendermintMessage {
             }
             MESSAGE_ID_PROPOSAL_BLOCK => {
                 let item_count = rlp.item_count()?;
-                if item_count != 4 {
+                if item_count != 5 {
                     return Err(DecoderError::RlpIncorrectListLen {
                         got: item_count,
-                        expected: 4,
+                        expected: 5,
                     })
                 }
                 let signature = rlp.at(1)?;
                 let view = rlp.at(2)?;
-                let compressed_message: Vec<u8> = rlp.val_at(3)?;
+                let priority = rlp.at(3)?;
+                let compressed_message: Vec<u8> = rlp.val_at(4)?;
                 let uncompressed_message = {
                     // TODO: Cache the Decoder object
                     let mut snappy_decoder = snap::Decoder::new();
@@ -259,6 +264,7 @@ impl Decodable for TendermintMessage {
                 TendermintMessage::ProposalBlock {
                     signature: signature.as_val()?,
                     view: view.as_val()?,
+                    priority: priority.as_val()?,
                     message: uncompressed_message,
                 }
             }

core/src/consensus/tendermint/network.rs

@@ -296,6 +296,7 @@ impl NetworkExtension<Event> for TendermintExtension {
             Ok(TendermintMessage::ProposalBlock {
                 signature,
                 view,
+                priority,
                 message,
             }) => {
                 let (result, receiver) = crossbeam::bounded(1);
@@ -304,6 +305,7 @@ impl NetworkExtension<Event> for TendermintExtension {
                         signature,
                         view,
                         message: message.clone(),
+                        priority: priority.clone(),
                         result,
                     })
                     .unwrap();

core/src/consensus/tendermint/params.rs

@@ -43,6 +43,8 @@ impl From<cjson::scheme::TendermintParams> for TendermintParams {
         TendermintParams {
             validators: Arc::new(DynamicValidator::new(p.validators)),
             timeouts: TimeoutParams {
+                promote: p.timeout_promote.map_or(dt.promote, to_duration),
+                promote_delta: p.timeout_promote_delta.map_or(dt.promote_delta, to_duration),
                 propose: p.timeout_propose.map_or(dt.propose, to_duration),
                 propose_delta: p.timeout_propose_delta.map_or(dt.propose_delta, to_duration),
                 prevote: p.timeout_prevote.map_or(dt.prevote, to_duration),
@@ -75,6 +77,8 @@ pub struct TimeGapParams {
 /// Base timeout of each step in ms.
 #[derive(Debug, Copy, Clone)]
 pub struct TimeoutParams {
+    pub promote: Duration,
+    pub promote_delta: Duration,
     pub propose: Duration,
     pub propose_delta: Duration,
     pub prevote: Duration,
@@ -87,6 +91,8 @@ pub struct TimeoutParams {
 impl Default for TimeoutParams {
     fn default() -> Self {
         TimeoutParams {
+            promote: Duration::from_millis(2000),
+            promote_delta: Duration::from_millis(500),
             propose: Duration::from_millis(1000),
             propose_delta: Duration::from_millis(500),
             prevote: Duration::from_millis(1000),

core/src/consensus/tendermint/worker.rs

@@ -22,7 +22,7 @@ use std::thread::{Builder, JoinHandle};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use ccrypto::sha256;
-use ckey::{public_to_address, verify_schnorr, Address, SchnorrSignature};
+use ckey::{public_to_address, verify_schnorr, Address, Public, SchnorrSignature};
 use cnetwork::{EventSender, NodeId};
 use crossbeam_channel as crossbeam;
 use ctypes::transaction::{Action, Transaction};
@@ -32,7 +32,7 @@ use parking_lot::RwLock;
 use primitives::{u256_from_u128, Bytes, U256};
 use rlp::{Encodable, Rlp};
 use vrf::openssl::{CipherSuite, ECVRF};
-use vrf::VRF;
+use vrf::{openssl::Error as VRFError, VRF};
 
 use super::super::BitSet;
 use super::backup::{backup, restore, BackupView};
@@ -160,6 +160,7 @@ pub enum Event {
     ProposalBlock {
         signature: SchnorrSignature,
         view: View,
+        priority: PriorityMessage,
         message: Bytes,
         result: crossbeam::Sender<Option<Arc<dyn ConsensusClient>>>,
     },
@@ -344,22 +345,14 @@ impl Worker {
                                 inner.restore();
                                 result.send(()).unwrap();
                             }
-                            Ok(Event::Priority {
-                                round,
-                                signer_idx,
-                                message,
-                                result,
-                            }) => {
-                                inner.on_priority_message(round, signer_idx, message);
-                                result.send(()).unwrap();
-                            }
                             Ok(Event::ProposalBlock {
                                 signature,
                                 view,
+                                priority,
                                 message,
                                 result,
                             }) => {
-                                let client = inner.on_proposal_message(signature, view, message);
+                                let client = inner.on_proposal_message(signature, view, priority, message);
                                 result.send(client).unwrap();
                             }
                             Ok(Event::StepState {
@@ -435,11 +428,12 @@ impl Worker {
         current_seed: &VRFSeed,
         prev_seed: &VRFSeed,
         prev_round: &SortitionRound,
+        signer_pubkey: &Public,
         prev_proof: &[u8],
-    ) -> Result<(), Error> {
+    ) -> Result<bool, VRFError> {
         let vrf_inst = self.sortition_scheme.vrf_inst.write();
-        let message = [&prev_seed[..], &prev_round.height.to_be_bytes(), &prev_round.view.to_be_bytes()].concat();
-        Ok(())
+        let message = prev_seed.generate_next_msg(prev_round.height, prev_round.view);
+        vrf_inst.verify(signer_pubkey, prev_proof, &message).map(|expected_seed| expected_seed == current_seed.to_vec())
     }
 
     fn fetch_vrf_seed(&self, block_hash: BlockHash) -> Option<VRFSeed> {
@@ -448,6 +442,12 @@ impl Worker {
         Some(TendermintSealView::new(&block_seal).vrf_seed().unwrap())
     }
 
+    fn fetch_vrf_seed_proof(&self, block_hash: BlockHash) -> Option<Vec<u8>> {
+        let block_header = self.client().block_header(&block_hash.into())?;
+        let block_seal = block_header.seal();
+        Some(TendermintSealView::new(&block_seal).vrf_seed_proof().unwrap())
+    }
+
     fn prev_vrf_seed(&self) -> VRFSeed {
         let parent_header =
             self.prev_block_header_of_height(self.height).expect("Height is increased when previous block is imported");
@@ -1260,8 +1260,7 @@ impl Worker {
                 parent_seal_view.parent_block_finalized_view().map_err(|_| BlockError::InvalidSeal)?;
             let current_vrf_proof = current_seal_view.vrf_seed_proof().map_err(|_| BlockError::InvalidSeal)?;
 
-            let message =
-                [&parent_vrf_seed[..], &parent.number().to_be_bytes(), &parent_fianlized_view.to_be_bytes()].concat();
+            let message = parent_vrf_seed.generate_next_msg(parent.number(), parent_fianlized_view);
 
             let current_vrf_seed =
                 TendermintSealView::new(&current_seal).vrf_seed().map_err(|_| BlockError::InvalidSeal)?;
@@ -1843,40 +1842,15 @@ impl Worker {
         result.send(message.rlp_bytes().into_vec()).unwrap();
     }
 
-    //FIXME: Log errors
-    fn on_priority_message(&mut self, round: SortitionRound, signer_idx: usize, message: PriorityMessage) {
-        if let Some(c) = self.client.upgrade() {
-            let height = round.height;
-            let view = round.view;
-            if let Some(parent_hash) = c.block_hash(&BlockId::Number(height - 1)) {
-                let signer_public = self.validators.get(&parent_hash, signer_idx);
-                //FIXME: Do not recalculate seed values with heavy VRF operations.
-                //FIXME: store block_seed into each block.
-                let concatenated = [height.to_be_bytes(), view.to_be_bytes()].concat();
-                let expected_seed =
-                    self.signer.vrf_hash(sha256(concatenated), &mut self.sortition_scheme.vrf_inst.write());
-                //FIXME: Handle errors
-                let voting_power = self
-                    .validators
-                    .normalized_voting_power(&parent_hash, signer_idx, self.sortition_scheme.total_power)
-                    .unwrap();
-                match expected_seed.map(|seed| seed == message.seed.to_vec()) {
-                    Ok(true) => match message.verify(&signer_public, voting_power, &self.sortition_scheme) {
-                        Ok(true) => {}
-                        _ => return,
-                    },
-                    _ => return,
-                };
-
-                self.sortition_infos.insert(&message, signer_idx, round);
-            }
-        }
+    fn get_voting_power(&self, block_hash: &BlockHash, signer_idx: usize) -> u64 {
+        self.validators.normalized_voting_power(block_hash, signer_idx, self.sortition_scheme.total_power).unwrap()
     }
 
     fn on_proposal_message(
         &mut self,
         signature: SchnorrSignature,
         proposed_view: View,
+        priority: PriorityMessage,
         bytes: Bytes,
     ) -> Option<Arc<dyn ConsensusClient>> {
         let c = self.client.upgrade()?;
@@ -1935,6 +1909,33 @@ impl Worker {
                 _ => {}
             }
 
+            // priority verification block
+            {
+                if let (Some(parent_seed), Some(parent_seed_proof)) =
+                    (self.fetch_vrf_seed(*parent_hash), self.fetch_vrf_seed_proof(*parent_hash))
+                {
+                    self.verify_vrf_seed(
+                        &priority.seed(),
+                        &parent_seed,
+                        &SortitionRound {
+                            height: self.height - 1,
+                            view: self.finalized_view_of_previous_block,
+                        },
+                        &signer_public,
+                        &parent_seed_proof,
+                    );
+
+                    let voting_power = self.get_voting_power(&parent_hash, message.signer_index());
+                    match priority.verify(&signer_public, voting_power, &self.sortition_scheme) {
+                        Ok(true) => {}
+                        _ => {
+                            cwarn!(ENGINE, "Proposal verification failed");
+                            return None
+                        }
+                    }
+                }
+            }
+
             if self.votes.is_old_or_known(&message) {
                 cdebug!(ENGINE, "Proposal is already known");
                 return None

json/src/scheme/tendermint.rs

@@ -26,6 +26,10 @@ use crate::uint::Uint;
 pub struct TendermintParams {
     /// Valid validators.
     pub validators: Vec<Public>,
+    /// Promote step timeout in milliseconds.
+    pub timeout_promote: Option<Uint>,
+    /// Promote step timeout delta in milliseconds.
+    pub timeout_promote_delta: Option<Uint>,
     /// Propose step timeout in milliseconds.
     pub timeout_propose: Option<Uint>,
     /// Propose step timeout delta in milliseconds.