code: Events and SM improvements

Code/common/src/round.rs

@@ -17,6 +17,7 @@ pub enum Round {
 impl Round {
     /// The initial, zero round.
     pub const INITIAL: Round = Round::new(0);
+    pub const NIL: Round = Round::new(-1);
 
     /// Create a new round.
     ///

Code/consensus/src/executor.rs

@@ -36,7 +36,7 @@ where
     private_key: Secret<PrivateKey<Ctx>>,
     address: Ctx::Address,
     validator_set: Ctx::ValidatorSet,
-    round: Round,
+    pub round: Round,
     votes: VoteKeeper<Ctx>,
     round_states: BTreeMap<Round, RoundState<Ctx>>,
 }
@@ -50,6 +50,7 @@ where
     Vote(SignedVote<Ctx>),
     Decide(Round, Ctx::Value),
     ScheduleTimeout(Timeout),
+    NewRound(Round),
 }
 
 impl<Ctx> Executor<Ctx>
@@ -64,7 +65,7 @@ where
     ) -> Self {
         let votes = VoteKeeper::new(
             height.clone(),
-            Round::INITIAL,
+            Round::NIL,
             validator_set.total_voting_power(),
         );
 
@@ -73,7 +74,7 @@ where
             private_key: Secret::new(private_key),
             address,
             validator_set,
-            round: Round::INITIAL,
+            round: Round::NIL,
             votes,
             round_states: BTreeMap::new(),
         }
@@ -92,13 +93,9 @@ where
 
         match round_msg {
             RoundMessage::NewRound(round) => {
-                // TODO: check if we are the proposer
-
                 // XXX: Check if there is an existing state?
-                self.round_states
-                    .insert(round, RoundState::default().new_round(round));
-
-                None
+                assert!(self.round < round);
+                Some(Message::NewRound(round))
             }
 
             RoundMessage::Proposal(proposal) => {
@@ -141,6 +138,11 @@ where
             RoundEvent::NewRound
         };
 
+        assert!(self.round < round);
+        self.round_states
+            .insert(round, RoundState::default().new_round(round));
+        self.round = round;
+
         self.apply_event(round, event)
     }
 
@@ -239,8 +241,26 @@ where
 
         let data = RoundData::new(round, &self.height, &self.address);
 
+        // Multiplex the event with the round state.
+        let mux_event = match event {
+            RoundEvent::PolkaValue(value_id) => match round_state.proposal {
+                Some(ref proposal) if proposal.value().id() == value_id => {
+                    RoundEvent::ProposalAndPolkaCurrent(proposal.clone())
+                }
+                _ => RoundEvent::PolkaAny,
+            },
+            RoundEvent::PrecommitValue(value_id) => match round_state.proposal {
+                Some(ref proposal) if proposal.value().id() == value_id => {
+                    RoundEvent::ProposalAndPrecommitValue(proposal.clone())
+                }
+                _ => RoundEvent::PrecommitAny,
+            },
+
+            _ => event,
+        };
+
         // Apply the event to the round state machine
-        let transition = round_state.apply_event(&data, event);
+        let transition = round_state.apply_event(&data, mux_event);
 
         // Update state
         self.round_states.insert(round, transition.next_state);

Code/round/src/events.rs

@@ -5,17 +5,20 @@ pub enum Event<Ctx>
 where
     Ctx: Context,
 {
-    NewRound,                     // Start a new round, not as proposer.
-    NewRoundProposer(Ctx::Value), // Start a new round and propose the Value.
-    Proposal(Ctx::Proposal),      // Receive a proposal with possible polka round.
-    ProposalInvalid,              // Receive an invalid proposal.
-    PolkaAny,                     // Receive +2/3 prevotes for anything.
-    PolkaNil,                     // Receive +2/3 prevotes for nil.
-    PolkaValue(ValueId<Ctx>),     // Receive +2/3 prevotes for Value.
-    PrecommitAny,                 // Receive +2/3 precommits for anything.
-    PrecommitValue(ValueId<Ctx>), // Receive +2/3 precommits for Value.
-    RoundSkip,                    // Receive +1/3 votes from a higher round.
-    TimeoutPropose,               // Timeout waiting for proposal.
-    TimeoutPrevote,               // Timeout waiting for prevotes.
-    TimeoutPrecommit,             // Timeout waiting for precommits.
+    NewRound,                                 // Start a new round, not as proposer.L20
+    NewRoundProposer(Ctx::Value),             // Start a new round and propose the Value.L14
+    Proposal(Ctx::Proposal),                  // Receive a proposal. L22 + L23 (valid)
+    ProposalAndPolkaPrevious(Ctx::Proposal), // Recieved a proposal and a polka value from a previous round. L28 + L29 (valid)
+    ProposalInvalid,                         // Receive an invalid proposal. L26 + L32 (invalid)
+    PolkaValue(ValueId<Ctx>),                // Receive +2/3 prevotes for valueId. L44
+    PolkaAny,                                // Receive +2/3 prevotes for anything. L34
+    PolkaNil,                                // Receive +2/3 prevotes for nil. L44
+    ProposalAndPolkaCurrent(Ctx::Proposal), // Receive +2/3 prevotes for Value in current round. L36
+    PrecommitAny,                           // Receive +2/3 precommits for anything. L47
+    ProposalAndPrecommitValue(Ctx::Proposal), // Receive +2/3 precommits for Value. L49
+    PrecommitValue(ValueId<Ctx>),           // Receive +2/3 precommits for ValueId. L51
+    RoundSkip, // Receive +1/3 messages from a higher round. OneCorrectProcessInHigherRound, L55
+    TimeoutPropose, // Timeout waiting for proposal. L57
+    TimeoutPrevote, // Timeout waiting for prevotes. L61
+    TimeoutPrecommit, // Timeout waiting for precommits. L65
 }

Code/round/src/state.rs

@@ -76,25 +76,10 @@ where
             ..self
         }
     }
-
-    pub fn next_step(self) -> Self {
-        let step = match self.step {
-            Step::NewRound => Step::Propose,
-            Step::Propose => Step::Prevote,
-            Step::Prevote => Step::Precommit,
-            _ => self.step,
-        };
-
+    pub fn with_step(self, step: Step) -> Self {
         Self { step, ..self }
     }
 
-    pub fn commit_step(self) -> Self {
-        Self {
-            step: Step::Commit,
-            ..self
-        }
-    }
-
     pub fn set_locked(self, value: Ctx::Value) -> Self {
         Self {
             locked: Some(RoundValue::new(value, self.round)),