Merge branch 'main' of github.com:informalsystems/malachite into main

code/Cargo.toml

@@ -24,6 +24,7 @@ members = [
   # Test
   "crates/test",
   "crates/test/mbt",
+  "crates/driver/test-utils",
 
   # Starknet
   "crates/starknet/*",
@@ -50,7 +51,7 @@ inherits = "release"
 debug = true
 
 [workspace.lints.rust]
-unused_crate_dependencies = "warn"
+# None for now
 
 [workspace.dependencies]
 malachite-actors           = { version = "0.1.0", path = "crates/actors" }
@@ -67,11 +68,14 @@ malachite-metrics          = { version = "0.1.0", path = "crates/metrics" }
 malachite-node             = { version = "0.1.0", path = "crates/node" }
 malachite-proto            = { version = "0.1.0", path = "crates/proto" }
 malachite-round            = { version = "0.1.0", path = "crates/round" }
-malachite-test             = { version = "0.1.0", path = "crates/test" }
-malachite-test-mbt         = { version = "0.1.0", path = "crates/test/mbt" }
 malachite-vote             = { version = "0.1.0", path = "crates/vote" }
 malachite-signing-ed25519  = { version = "0.1.0", path = "crates/signing-ed25519" }
 
+# Test
+malachite-test              = { version = "0.1.0", path = "crates/test" }
+malachite-test-mbt          = { version = "0.1.0", path = "crates/test/mbt" }
+malachite-driver-test-utils = { version = "0.1.0", path = "crates/driver/test-utils" }
+
 # Starknet
 malachite-starknet-host      = { version = "0.1.0", path = "crates/starknet/host" }
 malachite-starknet-app       = { version = "0.1.0", path = "crates/starknet/app" }

code/crates/actors/src/consensus.rs

@@ -14,7 +14,7 @@ use malachite_common::{
     CommitCertificate, Context, Round, SignedExtension, Timeout, TimeoutStep, ValidatorSet,
 };
 use malachite_config::TimeoutConfig;
-use malachite_consensus::{Effect, Resume};
+use malachite_consensus::{Effect, Resume, ValueToPropose};
 use malachite_metrics::Metrics;
 
 use crate::block_sync::BlockSyncRef;
@@ -233,7 +233,13 @@ where
                     .process_input(
                         &myself,
                         state,
-                        ConsensusInput::ProposeValue(height, round, Round::Nil, value, extension),
+                        ConsensusInput::Propose(ValueToPropose {
+                            height,
+                            round,
+                            valid_round: Round::Nil,
+                            value,
+                            extension,
+                        }),
                     )
                     .await;
 
@@ -296,14 +302,24 @@ where
                             return Ok(());
                         };
 
+                        self.host.call_and_forward(
+                            |reply_to| HostMsg::ProcessSyncedBlock {
+                                height: block.certificate.height,
+                                round: block.certificate.round,
+                                validator_address: state.consensus.address().clone(),
+                                block_bytes: block.block_bytes.clone(),
+                                reply_to,
+                            },
+                            &myself,
+                            |proposed| Msg::<Ctx>::ReceivedProposedValue(proposed),
+                            None,
+                        )?;
+
                         if let Err(e) = self
                             .process_input(
                                 &myself,
                                 state,
-                                ConsensusInput::ReceivedSyncedBlock(
-                                    block.block_bytes,
-                                    block.certificate,
-                                ),
+                                ConsensusInput::CommitCertificate(block.certificate),
                             )
                             .await
                         {
@@ -404,7 +420,7 @@ where
 
             Msg::ReceivedProposedValue(value) => {
                 let result = self
-                    .process_input(&myself, state, ConsensusInput::ReceivedProposedValue(value))
+                    .process_input(&myself, state, ConsensusInput::ProposedValue(value))
                     .await;
 
                 if let Err(e) = result {
@@ -601,30 +617,6 @@ where
 
                 Ok(Resume::Continue)
             }
-
-            Effect::SyncedBlock {
-                height,
-                round,
-                validator_address,
-                block_bytes,
-            } => {
-                debug!(%height, "Consensus received synced block, sending to host");
-
-                self.host.call_and_forward(
-                    |reply_to| HostMsg::ProcessSyncedBlockBytes {
-                        height,
-                        round,
-                        validator_address,
-                        block_bytes,
-                        reply_to,
-                    },
-                    myself,
-                    |proposed| Msg::<Ctx>::ReceivedProposedValue(proposed),
-                    None,
-                )?;
-
-                Ok(Resume::Continue)
-            }
         }
     }
 }

code/crates/actors/src/host.rs

@@ -104,7 +104,7 @@ pub enum HostMsg<Ctx: Context> {
     },
 
     // Synced block
-    ProcessSyncedBlockBytes {
+    ProcessSyncedBlock {
         height: Ctx::Height,
         round: Round,
         validator_address: Ctx::Address,

code/crates/common/src/lib.rs

@@ -2,7 +2,7 @@
 
 #![no_std]
 #![forbid(unsafe_code)]
-#![deny(unused_crate_dependencies, trivial_casts, trivial_numeric_casts)]
+#![deny(trivial_casts, trivial_numeric_casts)]
 #![warn(
     missing_docs,
     rustdoc::broken_intra_doc_links,

code/crates/consensus/Cargo.toml

@@ -17,7 +17,6 @@ malachite-driver.workspace  = true
 malachite-metrics.workspace = true
 
 async-recursion = { workspace = true }
-bytes            = { workspace = true, features = ["serde"] }
 genawaiter      = { workspace = true }
 derive-where    = { workspace = true }
 libp2p-identity = { workspace = true, features = ["peerid"] }
@@ -27,3 +26,6 @@ tracing         = { workspace = true }
 
 [lints]
 workspace = true
+
+[dev-dependencies]
+malachite-test = { workspace = true }

code/crates/consensus/src/effect.rs

@@ -1,4 +1,3 @@
-use bytes::Bytes;
 use derive_where::derive_where;
 
 use malachite_common::*;
@@ -62,15 +61,6 @@ where
     /// Consensus has decided on a value
     /// Resume with: [`Resume::Continue`]
     Decide { certificate: CommitCertificate<Ctx> },
-
-    /// Consensus has received a synced decided block
-    /// Resume with: [`Resume::Continue`]
-    SyncedBlock {
-        height: Ctx::Height,
-        round: Round,
-        validator_address: Ctx::Address,
-        block_bytes: Bytes,
-    },
 }
 
 /// A value with which the consensus process can be resumed after yielding an [`Effect`].

code/crates/consensus/src/handle.rs

@@ -3,20 +3,20 @@ use crate::prelude::*;
 mod decide;
 mod driver;
 mod proposal;
-mod propose_value;
-mod received_proposed_value;
+mod propose;
+mod proposed_value;
 mod signature;
 mod start_height;
-mod synced_block;
+mod sync;
 mod timeout;
 mod validator_set;
 mod vote;
 
 use proposal::on_proposal;
-use propose_value::propose_value;
-use received_proposed_value::on_received_proposed_value;
+use propose::on_propose;
+use proposed_value::on_proposed_value;
 use start_height::reset_and_start_height;
-use synced_block::on_received_synced_block;
+use sync::on_commit_certificate;
 use timeout::on_timeout_elapsed;
 use vote::on_vote;
 
@@ -48,25 +48,11 @@ where
         }
         Input::Vote(vote) => on_vote(co, state, metrics, vote).await,
         Input::Proposal(proposal) => on_proposal(co, state, metrics, proposal).await,
-        Input::ProposeValue(height, round, valid_round, value, extension) => {
-            propose_value(
-                co,
-                state,
-                metrics,
-                height,
-                round,
-                valid_round,
-                value,
-                extension,
-            )
-            .await
-        }
+        Input::Propose(value) => on_propose(co, state, metrics, value).await,
         Input::TimeoutElapsed(timeout) => on_timeout_elapsed(co, state, metrics, timeout).await,
-        Input::ReceivedProposedValue(value) => {
-            on_received_proposed_value(co, state, metrics, value).await
-        }
-        Input::ReceivedSyncedBlock(block_bytes, commits) => {
-            on_received_synced_block(co, state, metrics, block_bytes, commits).await
+        Input::ProposedValue(value) => on_proposed_value(co, state, metrics, value).await,
+        Input::CommitCertificate(certificate) => {
+            on_commit_certificate(co, state, metrics, certificate).await
         }
     }
 }

code/crates/consensus/src/handle/decide.rs

@@ -14,8 +14,8 @@ where
     let proposal_round = proposal.round();
     let value = proposal.value();
 
-    // Restore the commits. Note that they will be removed from `state`
-    let commits = state.restore_precommits(height, proposal_round, value);
+    // We only decide proposals for the current height
+    assert_eq!(height, state.driver.height());
 
     // Clean proposals and values
     state.remove_full_proposals(height);
@@ -46,7 +46,17 @@ where
         }
     }
 
-    let certificate = CommitCertificate::new(height, proposal_round, value.id(), commits);
+    // Look for an existing certificate
+    let certificate = state
+        .driver
+        .get_certificate(proposal_round, value.id())
+        .cloned()
+        .unwrap_or_else(|| {
+            // Restore the commits. Note that they will be removed from `state`
+            let commits = state.restore_precommits(height, proposal_round, value);
+            // TODO: should we verify we have 2/3rd commits?
+            CommitCertificate::new(height, proposal_round, value.id(), commits)
+        });
 
     perform!(co, Effect::Decide { certificate });
 

code/crates/consensus/src/handle/propose_value.rs → code/crates/consensus/src/handle/propose.rs

@@ -1,22 +1,25 @@
 use crate::prelude::*;
 
 use crate::handle::driver::apply_driver_input;
-use crate::types::ProposedValue;
+use crate::types::{ProposedValue, ValueToPropose};
 
-#[allow(clippy::too_many_arguments)]
-pub async fn propose_value<Ctx>(
+pub async fn on_propose<Ctx>(
     co: &Co<Ctx>,
     state: &mut State<Ctx>,
     metrics: &Metrics,
-    height: Ctx::Height,
-    round: Round,
-    valid_round: Round,
-    value: Ctx::Value,
-    extension: Option<SignedExtension<Ctx>>,
+    value: ValueToPropose<Ctx>,
 ) -> Result<(), Error<Ctx>>
 where
     Ctx: Context,
 {
+    let ValueToPropose {
+        height,
+        round,
+        valid_round,
+        value,
+        extension,
+    } = value;
+
     if state.driver.height() != height {
         warn!(
             "Ignoring proposal for height {height}, current height: {}",
@@ -41,7 +44,7 @@ where
         height,
         round,
         valid_round,
-        validator_address: state.driver.address().clone(),
+        validator_address: state.address().clone(),
         value: value.clone(),
         validity: Validity::Valid,
         extension,