[WIP] Make the acceptable time gaps configurable

Author: HoOngEe

core/src/consensus/tendermint/mod.rs

@@ -94,7 +94,8 @@ impl Tendermint {
         let validators = Arc::clone(&our_params.validators);
         let machine = Arc::new(machine);
 
-        let (join, extension_initializer, inner, quit_tendermint) = worker::spawn(our_params.validators);
+        let (join, extension_initializer, inner, quit_tendermint) =
+            worker::spawn(our_params.validators, our_params.allowed_timegaps);
         let action_handlers: Vec<Arc<ActionHandler>> = vec![Arc::new(stake)];
         let chain_notify = Arc::new(TendermintChainNotify::new(inner.clone()));
 

core/src/consensus/tendermint/params.rs

@@ -16,6 +16,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::time::Duration as StdDuration;
 
 use cjson;
 use ckey::{Address, PlatformAddress};
@@ -33,13 +34,16 @@ pub struct TendermintParams {
     pub timeouts: TimeoutParams,
     /// Reward per block in base units.
     pub block_reward: u64,
+    /// Allowed time gap from the system time and the block generation time.
+    pub allowed_timegaps: TimegapParams,
     /// Tokens distributed at genesis.
     pub genesis_stakes: HashMap<Address, u64>,
 }
 
 impl From<cjson::scheme::TendermintParams> for TendermintParams {
     fn from(p: cjson::scheme::TendermintParams) -> Self {
         let dt = TimeoutParams::default();
+        let dtg = TimegapParams::default();
         TendermintParams {
             validators: new_validator_set(p.validators),
             timeouts: TimeoutParams {
@@ -51,6 +55,16 @@ impl From<cjson::scheme::TendermintParams> for TendermintParams {
                 precommit_delta: p.timeout_precommit_delta.map_or(dt.precommit_delta, to_duration),
                 commit: p.timeout_commit.map_or(dt.commit, to_duration),
             },
+            allowed_timegaps: TimegapParams {
+                allowed_past_gap: p.allowed_past_timegap.map_or(dtg.allowed_past_gap, |x| {
+                    let mx: u64 = x.into();
+                    StdDuration::from_millis(mx)
+                }),
+                allowed_future_gap: p.allowed_future_timegap.map_or(dtg.allowed_future_gap, |x| {
+                    let mx: u64 = x.into();
+                    StdDuration::from_millis(mx)
+                }),
+            },
             block_reward: p.block_reward.map_or(0, Into::into),
             genesis_stakes: p
                 .genesis_stakes
@@ -67,6 +81,20 @@ fn to_duration(ms: cjson::uint::Uint) -> Duration {
     Duration::milliseconds(ms as i64)
 }
 
+pub struct TimegapParams {
+    pub allowed_past_gap: StdDuration,
+    pub allowed_future_gap: StdDuration,
+}
+
+impl Default for TimegapParams {
+    fn default() -> Self {
+        TimegapParams {
+            allowed_past_gap: StdDuration::from_millis(30000),
+            allowed_future_gap: StdDuration::from_millis(5000),
+        }
+    }
+}
+
 /// Base timeout of each step in ms.
 #[derive(Debug, Copy, Clone)]
 pub struct TimeoutParams {

core/src/consensus/tendermint/worker.rs

@@ -32,6 +32,7 @@ use rlp::{Encodable, UntrustedRlp};
 use super::backup::{backup, restore, BackupView};
 use super::message::*;
 use super::network;
+use super::params::TimegapParams;
 use super::types::{BitSet, Height, Proposal, Step, TendermintSealView, TendermintState, TwoThirdsMajority, View};
 use super::{
     BlockHash, ENGINE_TIMEOUT_BROADCAST_STEP_STATE, ENGINE_TIMEOUT_EMPTY_PROPOSAL, ENGINE_TIMEOUT_TOKEN_NONCE_BASE,
@@ -57,8 +58,8 @@ type SpawnResult = (
     crossbeam::Sender<()>,
 );
 
-pub fn spawn(validators: Arc<ValidatorSet>) -> SpawnResult {
-    Worker::spawn(validators)
+pub fn spawn(validators: Arc<ValidatorSet>, allowed_time_gaps: TimegapParams) -> SpawnResult {
+    Worker::spawn(validators, allowed_time_gaps)
 }
 
 struct Worker {
@@ -87,7 +88,7 @@ struct Worker {
     validators: Arc<ValidatorSet>,
     /// Channel to the network extension, must be set later.
     extension: EventSender<network::Event>,
-
+    allowed_time_gaps: TimegapParams,
     timeout_token_nonce: usize,
 }
 
@@ -167,7 +168,12 @@ pub enum Event {
 impl Worker {
     #![cfg_attr(feature = "cargo-clippy", allow(clippy::new_ret_no_self))]
     /// Create a new instance of Tendermint engine
-    fn new(validators: Arc<ValidatorSet>, extension: EventSender<network::Event>, client: Weak<EngineClient>) -> Self {
+    fn new(
+        validators: Arc<ValidatorSet>,
+        extension: EventSender<network::Event>,
+        client: Weak<EngineClient>,
+        allowed_time_gaps: TimegapParams,
+    ) -> Self {
         Worker {
             client,
             height: 1,
@@ -182,12 +188,12 @@ impl Worker {
             extension,
             votes_received: BitSet::new(),
             votes_received_changed: false,
-
+            allowed_time_gaps,
             timeout_token_nonce: ENGINE_TIMEOUT_TOKEN_NONCE_BASE,
         }
     }
 
-    fn spawn(validators: Arc<ValidatorSet>) -> SpawnResult {
+    fn spawn(validators: Arc<ValidatorSet>, allowed_timegaps: TimegapParams) -> SpawnResult {
         let (sender, receiver) = crossbeam::unbounded();
         let (quit, quit_receiver) = crossbeam::bounded(1);
         let (extension_initializer, extension_receiver) = crossbeam::bounded(1);
@@ -215,7 +221,7 @@ impl Worker {
                 }
                 };
                 validators.register_client(Weak::clone(&client));
-                let mut inner = Self::new(validators, extension, client);
+                let mut inner = Self::new(validators, extension, client, allowed_timegaps);
                 loop {
                     crossbeam::select! {
                     recv(receiver) -> msg => {
@@ -690,11 +696,12 @@ impl Worker {
     }
 
     fn is_generation_time_relevant(&self, proposal: &Header) -> bool {
-        const ACCEPTABLE_FUTURE_GAP: Duration = Duration::from_secs(5);
-        const ACCEPTABLE_PAST_GAP: Duration = Duration::from_secs(30);
+        let acceptable_past_gap: Duration = self.allowed_time_gaps.allowed_past_gap;
+        let acceptable_future_gap: Duration = self.allowed_time_gaps.allowed_future_gap;
+
         let now = SystemTime::now();
-        let allowed_min = now - ACCEPTABLE_PAST_GAP;
-        let allowed_max = now + ACCEPTABLE_FUTURE_GAP;
+        let allowed_min = now - acceptable_past_gap;
+        let allowed_max = now + acceptable_future_gap;
         let block_generation_time = UNIX_EPOCH.checked_add(Duration::from_secs(proposal.timestamp()));
 
         match block_generation_time {

json/src/scheme/tendermint.rs

@@ -44,6 +44,10 @@ pub struct TendermintParams {
     pub block_reward: Option<Uint>,
     /// How much tokens are distributed at Genesis?
     pub genesis_stakes: Option<HashMap<PlatformAddress, u64>>,
+    /// allowed past time gap in milliseconds.
+    pub allowed_past_timegap: Option<Uint>,
+    /// allowed future time gap in milliseconds.
+    pub allowed_future_timegap: Option<Uint>,
 }
 
 /// Tendermint engine deserialization.