Wait in propose step when generated proposal is empty

Wait for (proposal timeout)/2. Empty proposals are generated
immediately, so it would not cause a problem.

Author: Hyunsik Jeong

core/src/block.rs

@@ -340,6 +340,7 @@ impl LockedBlock {
 /// A block that has a valid seal.
 ///
 /// The block's header has valid seal arguments. The block cannot be reversed into a `ClosedBlock` or `OpenBlock`.
+#[derive(Clone)]
 pub struct SealedBlock {
     block: ExecutedBlock,
 }

core/src/consensus/tendermint/mod.rs

@@ -63,7 +63,9 @@ use crate::BlockId;
 use ChainNotify;
 
 /// Timer token representing the consensus step timeouts.
-pub const ENGINE_TIMEOUT_TOKEN_NONCE_BASE: TimerToken = 23;
+const ENGINE_TIMEOUT_TOKEN_NONCE_BASE: TimerToken = 23;
+/// Timer token for empty proposal blocks.
+const ENGINE_TIMEOUT_EMPTY_PROPOSAL: TimerToken = 22;
 
 pub type BlockHash = H256;
 
@@ -96,6 +98,8 @@ struct TendermintInner {
     last_lock: View,
     /// hash of the proposed block, used for seal submission.
     proposal: Option<H256>,
+    /// Waiting proposal block, because it's empty
+    waiting_proposal: Option<SealedBlock>,
     /// The last view of the previous height
     last_confirmed_view: View,
     /// Set used to determine the current validators.
@@ -154,6 +158,7 @@ impl TendermintInner {
             lock_change: None,
             last_lock: 0,
             proposal: None,
+            waiting_proposal: None,
             last_confirmed_view: 0,
             validators: our_params.validators,
             block_reward: our_params.block_reward,
@@ -703,6 +708,21 @@ impl TendermintInner {
             panic!("Block is generated at unexpected step {:?}", self.step);
         }
 
+        if !sealed_block.transactions().is_empty() {
+            cdebug!(ENGINE, "Submit proposal {} immediatly", hash);
+            self.submit_proposal_block(sealed_block);
+        } else {
+            cdebug!(ENGINE, "Submit proposal {} after the half of the proposal timeout, because it's empty", hash);
+            self.step = TendermintState::ProposeWaitEmpty;
+            self.waiting_proposal = Some(sealed_block.clone());
+            self.extension().set_timer_empty_proposal(self.view);
+        }
+    }
+
+    fn submit_proposal_block(&mut self, sealed_block: &SealedBlock) {
+        let header = sealed_block.header();
+        let hash = header.hash();
+
         let vote_step =
             VoteStep::new(header.number() as Height, consensus_view(&header).expect("I am proposer"), Step::Propose);
         let vote_info = message_info_rlp(vote_step, Some(hash));
@@ -868,6 +888,23 @@ impl TendermintInner {
     }
 
     fn on_timeout(&mut self, token: usize) {
+        // Timeout from empty block generation
+        if token == ENGINE_TIMEOUT_EMPTY_PROPOSAL {
+            match self.step {
+                TendermintState::ProposeWaitEmpty => {
+                    let block = mem::replace(&mut self.waiting_proposal, None)
+                        .expect("waiting_proposal must not be None when in the ProposeWaitEmpty state");
+                    self.submit_proposal_block(&block);
+                }
+                _ => {
+                    self.waiting_proposal = None;
+                    cwarn!(ENGINE, "Empty proposal timer was not cleared.");
+                }
+            }
+            return
+        }
+
+        // Timeout from Tendermint step
         if self.extension().is_expired_timeout_token(token) {
             return
         }
@@ -889,6 +926,10 @@ impl TendermintInner {
                 cwarn!(ENGINE, "Propose timed out but block is not generated yet");
                 None
             }
+            TendermintState::ProposeWaitEmpty => {
+                cwarn!(ENGINE, "Propose timed out but still waiting for the empty block");
+                None
+            }
             TendermintState::Prevote if self.has_enough_any_votes() => {
                 ctrace!(ENGINE, "Prevote timeout.");
                 Some(Step::Precommit)
@@ -1545,12 +1586,20 @@ impl TendermintExtension {
     fn set_timer_step(&self, step: Step, view: View) {
         let expired_token_nonce = self.timeout_token_nonce.fetch_add(1, AtomicOrdering::SeqCst);
 
+        self.api.clear_timer(ENGINE_TIMEOUT_EMPTY_PROPOSAL).expect("Timer clear succeeds");
         self.api.clear_timer(expired_token_nonce).expect("Timer clear succeeds");
         self.api
             .set_timer_once(expired_token_nonce + 1, self.timeouts.timeout(step, view))
             .expect("Timer set succeeds");
     }
 
+    fn set_timer_empty_proposal(&self, view: View) {
+        self.api.clear_timer(ENGINE_TIMEOUT_EMPTY_PROPOSAL).expect("Timer clear succeeds");
+        self.api
+            .set_timer_once(ENGINE_TIMEOUT_EMPTY_PROPOSAL, self.timeouts.timeout(Step::Propose, view) / 2)
+            .expect("Timer set succeeds");
+    }
+
     fn on_proposal_message(&self, tendermint: MutexGuard<TendermintInner>, signature: SchnorrSignature, bytes: Bytes) {
         let c = match self.client.upgrade() {
             Some(c) => c,
@@ -1803,7 +1852,7 @@ impl NetworkExtension for TendermintExtension {
 
 impl TimeoutHandler for TendermintExtension {
     fn on_timeout(&self, token: TimerToken) {
-        debug_assert!(token >= ENGINE_TIMEOUT_TOKEN_NONCE_BASE);
+        debug_assert!(token >= ENGINE_TIMEOUT_TOKEN_NONCE_BASE || token == ENGINE_TIMEOUT_EMPTY_PROPOSAL);
         if let Some(c) = self.tendermint.upgrade() {
             c.on_timeout(token);
         }

core/src/consensus/tendermint/types.rs

@@ -32,6 +32,7 @@ pub enum TendermintState {
     ProposeWaitBlockGeneration {
         parent_hash: H256,
     },
+    ProposeWaitEmpty,
     Prevote,
     Precommit,
     Commit,
@@ -44,6 +45,7 @@ impl TendermintState {
             TendermintState::ProposeWaitBlockGeneration {
                 ..
             } => Step::Propose,
+            TendermintState::ProposeWaitEmpty => Step::Propose,
             TendermintState::Prevote => Step::Prevote,
             TendermintState::Precommit => Step::Precommit,
             TendermintState::Commit => Step::Commit,