fix(code/core-consensus): Reproduce and fix consensus being stuck with byzantine proposer

code/crates/core-types/src/signing.rs

@@ -45,7 +45,7 @@ where
 /// It is parameterized by a context type `Ctx` that defines the specific types used
 /// for votes, proposals, and other consensus-related data structures.
 ///
-/// Implementors of this trait are responsible for managing the private keys used for signing
+/// Implementers of this trait are responsible for managing the private keys used for signing
 /// and providing verification logic using the corresponding public keys.
 pub trait SigningProvider<Ctx>
 where

code/crates/test/app/src/app.rs

@@ -82,14 +82,23 @@ pub async fn run(
                 // we send back the very same value.
                 let proposal = match state.get_previously_built_value(height, round).await? {
                     Some(proposal) => {
-                        info!(value = %proposal.value.id(), "Re-using previously built value");
-                        proposal
+                        let new_proposal = state.propose_value(height, round).await?;
+                        error!(
+                            "XXX Not Re-using previously built value {:} but a new one {:}",
+                            proposal.value.id(),
+                            new_proposal.value.id()
+                        );
+                        new_proposal
                     }
                     None => {
                         // If we have not previously built a value for that very same height and round,
                         // we need to create a new value to propose and send it back to consensus.
-                        info!("Building a new value to propose");
-                        state.propose_value(height, round).await?
+                        let proposal = state.propose_value(height, round).await?;
+                        error!(
+                            "XXX Building a new value to propose {:}",
+                            proposal.value.id()
+                        );
+                        proposal
                     }
                 };
 

code/crates/test/app/src/state.rs

@@ -50,12 +50,17 @@ pub struct State {
 // order for each node to likely propose different values at
 // each round.
 fn seed_from_address(address: &Address) -> u64 {
-    address.into_inner().chunks(8).fold(0u64, |acc, chunk| {
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos() as u64;
+    let addr_seed = address.into_inner().chunks(8).fold(0u64, |acc, chunk| {
         let term = chunk.iter().fold(0u64, |acc, &x| {
             acc.wrapping_shl(8).wrapping_add(u64::from(x))
         });
         acc.wrapping_add(term)
-    })
+    });
+    addr_seed.wrapping_add(timestamp)
 }
 
 impl State {

code/crates/test/tests/it/wal.rs

@@ -194,3 +194,74 @@ async fn non_proposer_crashes_after_voting(params: TestParams) {
         )
         .await
 }
+
+#[tokio::test]
+async fn restart_with_byzantine_proposer() {
+    byzantine_proposer_crashes_after_proposing(TestParams {
+        value_payload: ValuePayload::ProposalAndParts,
+        ..TestParams::default()
+    })
+    .await
+}
+
+async fn byzantine_proposer_crashes_after_proposing(params: TestParams) {
+    #[derive(Clone, Debug, Default)]
+    struct State {
+        first_proposed_value: Option<LocallyProposedValue<TestContext>>,
+    }
+
+    const CRASH_HEIGHT: u64 = 3;
+
+    let mut test = TestBuilder::<State>::new();
+
+    test.add_node()
+        .with_voting_power(10)
+        .start()
+        .wait_until(CRASH_HEIGHT)
+        .crash()
+        .restart_after(Duration::from_secs(5))
+        .success();
+
+    test.add_node()
+        .with_voting_power(10)
+        .start()
+        .wait_until(CRASH_HEIGHT)
+        .crash()
+        .restart_after(Duration::from_secs(5))
+        .success();
+
+    test.add_node()
+        .with_voting_power(10)
+        .start()
+        .wait_until(CRASH_HEIGHT)
+        // Wait until this node proposes a value
+        .on_event(|event, state| match event {
+            Event::ProposedValue(value) => {
+                info!("Proposer proposed block: {:?}", value.value);
+                state.first_proposed_value = Some(value);
+                Ok(HandlerResult::ContinueTest)
+            }
+            _ => Ok(HandlerResult::WaitForNextEvent),
+        })
+        // Crash right after
+        .crash()
+        // Restart after 5 seconds
+        .restart_after(Duration::from_secs(5))
+        // Check that we replay messages from the WAL
+        .expect_wal_replay(CRASH_HEIGHT)
+        // Wait until it proposes a value again, while replaying WAL
+        // Check that it is the same value as the first time
+        .on_proposed_value(|_value, _state| Ok(HandlerResult::ContinueTest))
+        .wait_until(CRASH_HEIGHT + 2)
+        .success();
+
+    test.build()
+        .run_with_params(
+            Duration::from_secs(60),
+            TestParams {
+                enable_sync: false,
+                ..params
+            },
+        )
+        .await
+}