opt proposal

Author: danielxiangzl

config/src/config/consensus_config.rs

@@ -14,8 +14,8 @@ use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 // NOTE: when changing, make sure to update QuorumStoreBackPressureConfig::backlog_txn_limit_count as well.
-const MAX_SENDING_BLOCK_TXNS_AFTER_FILTERING: u64 = 3000;
-const MAX_SENDING_BLOCK_TXNS: u64 = 7000;
+const MAX_SENDING_BLOCK_TXNS_AFTER_FILTERING: u64 = 1700;
+const MAX_SENDING_BLOCK_TXNS: u64 = 4000;
 pub(crate) static MAX_RECEIVING_BLOCK_TXNS: Lazy<u64> =
     Lazy::new(|| 10000.max(2 * MAX_SENDING_BLOCK_TXNS));
 // stop reducing size at this point, so 1MB transactions can still go through
@@ -324,7 +324,7 @@ impl Default for ConsensusConfig {
             max_pending_rounds_in_commit_vote_cache: 100,
             optimistic_sig_verification: true,
             enable_round_timeout_msg: true,
-            enable_pipeline: false,
+            enable_pipeline: true,
         }
     }
 }

consensus/consensus-types/src/block.rs

@@ -5,9 +5,10 @@
 use crate::{
     block_data::{BlockData, BlockType},
     common::{Author, Payload, Round},
+    opt_block_data::OptBlockData,
     quorum_cert::QuorumCert,
 };
-use anyhow::{bail, ensure, format_err};
+use anyhow::{bail, ensure, format_err, Result};
 use aptos_bitvec::BitVec;
 use aptos_crypto::{bls12381, hash::CryptoHash, HashValue};
 use aptos_infallible::duration_since_epoch;
@@ -168,6 +169,10 @@ impl Block {
         self.block_data.is_nil_block()
     }
 
+    pub fn is_opt_block(&self) -> bool {
+        self.block_data.is_opt_block()
+    }
+
     #[cfg(any(test, feature = "fuzzing"))]
     pub fn make_genesis_block() -> Self {
         Self::make_genesis_block_from_ledger_info(&LedgerInfo::mock_genesis(None))
@@ -308,6 +313,19 @@ impl Block {
         }
     }
 
+    pub fn new_from_opt(
+        block_data: OptBlockData,
+        quorum_cert: QuorumCert,
+        failed_authors: Vec<(Round, Author)>,
+    ) -> Result<Self> {
+        let block_data = BlockData::new_from_opt(block_data, quorum_cert, failed_authors)?;
+        Ok(Block {
+            id: block_data.hash(),
+            block_data,
+            signature: None,
+        })
+    }
+
     pub fn validator_txns(&self) -> Option<&Vec<ValidatorTransaction>> {
         self.block_data.validator_txns()
     }
@@ -334,6 +352,13 @@ impl Block {
                 validator.verify(*proposal_ext.author(), &self.block_data, signature)?;
                 self.quorum_cert().verify(validator)
             },
+            BlockType::OptProposal { .. } => {
+                // Optimistic proposal is not signed by proposer
+                self.block_data()
+                    .grandparent_qc()
+                    .map_or(Ok(()), |qc| qc.verify(validator))?;
+                self.quorum_cert().verify(validator)
+            },
             BlockType::DAGBlock { .. } => bail!("We should not accept DAG block from others"),
         }
     }
@@ -442,6 +467,8 @@ impl Block {
     fn previous_bitvec(&self) -> BitVec {
         if let BlockType::DAGBlock { parents_bitvec, .. } = self.block_data.block_type() {
             parents_bitvec.clone()
+        } else if let BlockType::OptProposal { grandparent_qc, .. } = self.block_data.block_type() {
+            grandparent_qc.ledger_info().get_voters_bitvec().clone()
         } else {
             self.quorum_cert().ledger_info().get_voters_bitvec().clone()
         }

consensus/consensus-types/src/block_data.rs

@@ -4,13 +4,18 @@
 
 use crate::{
     common::{Author, Payload, Round},
+    opt_block_data::OptBlockData,
     proposal_ext::ProposalExt,
     quorum_cert::QuorumCert,
     vote_data::VoteData,
 };
+use anyhow::{bail, Result};
 use aptos_bitvec::BitVec;
-use aptos_crypto::hash::HashValue;
-use aptos_crypto_derive::{BCSCryptoHash, CryptoHasher};
+use aptos_crypto::{
+    hash::{CryptoHash, CryptoHasher},
+    HashValue,
+};
+use aptos_crypto_derive::CryptoHasher;
 use aptos_types::{
     aggregate_signature::AggregateSignature,
     block_info::BlockInfo,
@@ -49,6 +54,21 @@ pub enum BlockType {
     /// Proposal with extensions (e.g. system transactions).
     ProposalExt(ProposalExt),
 
+    /// Optimistic proposal
+    OptProposal {
+        validator_txns: Vec<ValidatorTransaction>,
+        /// T of the block (e.g. one or more transaction(s)
+        payload: Payload,
+        /// Author of the block that can be validated by the author's public key and the signature
+        author: Author,
+        /// Failed authors from the parent's block to this block.
+        /// I.e. the list of consecutive proposers from the
+        /// immediately preceeding rounds that didn't produce a successful block.
+        failed_authors: Vec<(Round, Author)>,
+        /// Grandparent QC, used to generate previous_bitvec
+        grandparent_qc: QuorumCert,
+    },
+
     /// A virtual block that's constructed by nodes from DAG, this is purely a local thing so
     /// we hide it from serde
     #[serde(skip_deserializing)]
@@ -63,7 +83,7 @@ pub enum BlockType {
     },
 }
 
-#[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq, CryptoHasher, BCSCryptoHash)]
+#[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq, CryptoHasher)]
 /// Block has the core data of a consensus block that should be persistent when necessary.
 /// Each block must know the id of its parent and keep the QuorurmCertificate to that parent.
 pub struct BlockData {
@@ -96,12 +116,34 @@ pub struct BlockData {
     block_type: BlockType,
 }
 
+impl CryptoHash for BlockData {
+    type Hasher = BlockDataHasher;
+
+    fn hash(&self) -> HashValue {
+        let mut state = Self::Hasher::default();
+        if self.is_opt_block() {
+            state.update(&self.epoch.to_be_bytes());
+            state.update(&self.round.to_be_bytes());
+            state.update(&self.timestamp_usecs.to_be_bytes());
+            state.update(
+                &bcs::to_bytes(self.quorum_cert().vote_data())
+                    .expect("Unable to serialize quorum cert vote data"),
+            );
+            state
+                .update(&bcs::to_bytes(self.block_type()).expect("Unable to serialize block type"));
+        } else {
+            state.update(&bcs::to_bytes(self).expect("Failed to serialize BlockData"));
+        }
+        state.finish()
+    }
+}
+
 impl BlockData {
     pub fn author(&self) -> Option<Author> {
         match &self.block_type {
-            BlockType::Proposal { author, .. } | BlockType::DAGBlock { author, .. } => {
-                Some(*author)
-            },
+            BlockType::Proposal { author, .. }
+            | BlockType::OptProposal { author, .. }
+            | BlockType::DAGBlock { author, .. } => Some(*author),
             BlockType::ProposalExt(p) => Some(*p.author()),
             _ => None,
         }
@@ -126,11 +168,18 @@ impl BlockData {
         }
     }
 
+    pub fn grandparent_qc(&self) -> Result<QuorumCert> {
+        match &self.block_type {
+            BlockType::OptProposal { grandparent_qc, .. } => Ok(grandparent_qc.clone()),
+            _ => bail!("Invalid block type"),
+        }
+    }
+
     pub fn payload(&self) -> Option<&Payload> {
         match &self.block_type {
-            BlockType::Proposal { payload, .. } | BlockType::DAGBlock { payload, .. } => {
-                Some(payload)
-            },
+            BlockType::Proposal { payload, .. }
+            | BlockType::DAGBlock { payload, .. }
+            | BlockType::OptProposal { payload, .. } => Some(payload),
             BlockType::ProposalExt(p) => p.payload(),
             _ => None,
         }
@@ -141,6 +190,9 @@ impl BlockData {
             BlockType::ProposalExt(proposal_ext) => proposal_ext.validator_txns(),
             BlockType::Proposal { .. } | BlockType::NilBlock { .. } | BlockType::Genesis => None,
             BlockType::DAGBlock { validator_txns, .. } => Some(validator_txns),
+            BlockType::OptProposal { validator_txns, .. } => {
+                (!validator_txns.is_empty()).then_some(validator_txns)
+            },
         }
     }
 
@@ -176,13 +228,18 @@ impl BlockData {
         matches!(self.block_type, BlockType::NilBlock { .. })
     }
 
+    pub fn is_opt_block(&self) -> bool {
+        matches!(self.block_type, BlockType::OptProposal { .. })
+    }
+
     /// the list of consecutive proposers from the immediately preceeding
     /// rounds that didn't produce a successful block
     pub fn failed_authors(&self) -> Option<&Vec<(Round, Author)>> {
         match &self.block_type {
             BlockType::Proposal { failed_authors, .. }
             | BlockType::NilBlock { failed_authors, .. }
-            | BlockType::DAGBlock { failed_authors, .. } => Some(failed_authors),
+            | BlockType::DAGBlock { failed_authors, .. }
+            | BlockType::OptProposal { failed_authors, .. } => Some(failed_authors),
             BlockType::ProposalExt(p) => Some(p.failed_authors()),
             BlockType::Genesis => None,
         }
@@ -353,6 +410,45 @@ impl BlockData {
         }
     }
 
+    // Converting OptBlockData to BlockData
+    // by adding QC and failed_authors
+    pub fn new_from_opt(
+        opt_block_data: OptBlockData,
+        quorum_cert: QuorumCert,
+        new_failed_authors: Vec<(Round, Author)>,
+    ) -> Result<Self> {
+        let OptBlockData {
+            epoch,
+            round,
+            timestamp_usecs,
+            parent_id: _,
+            block_type,
+        } = opt_block_data;
+        let block_type = match block_type {
+            BlockType::OptProposal {
+                validator_txns,
+                payload,
+                author,
+                failed_authors: _,
+                grandparent_qc,
+            } => BlockType::OptProposal {
+                validator_txns,
+                payload,
+                author,
+                failed_authors: new_failed_authors,
+                grandparent_qc,
+            },
+            _ => bail!("Invalid block type"),
+        };
+        Ok(Self {
+            epoch,
+            round,
+            timestamp_usecs,
+            quorum_cert,
+            block_type,
+        })
+    }
+
     /// It's a reconfiguration suffix block if the parent block's executed state indicates next epoch.
     pub fn is_reconfiguration_suffix(&self) -> bool {
         self.quorum_cert.certified_block().has_reconfiguration()

consensus/consensus-types/src/lib.rs

@@ -9,6 +9,8 @@ pub mod block_data;
 pub mod block_retrieval;
 pub mod common;
 pub mod epoch_retrieval;
+pub mod opt_block_data;
+pub mod opt_proposal_msg;
 pub mod order_vote;
 pub mod order_vote_msg;
 pub mod order_vote_proposal;