opt proposal

Author: danielxiangzl

config/src/config/consensus_config.rs

@@ -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

@@ -3,11 +3,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    block_data::{BlockData, BlockType},
-    common::{Author, Payload, Round},
-    quorum_cert::QuorumCert,
+    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 +166,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 +310,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 +349,11 @@ 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 +462,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

@@ -3,14 +3,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    common::{Author, Payload, Round},
-    proposal_ext::ProposalExt,
-    quorum_cert::QuorumCert,
-    vote_data::VoteData,
+    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 +47,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 +76,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,10 +109,28 @@ 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, .. } => {
+            BlockType::Proposal { author, .. } | BlockType::OptProposal { author, .. } | BlockType::DAGBlock { author, .. } => {
                 Some(*author)
             },
             BlockType::ProposalExt(p) => Some(*p.author()),
@@ -126,6 +157,13 @@ 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, .. } => {
@@ -139,8 +177,9 @@ impl BlockData {
     pub fn validator_txns(&self) -> Option<&Vec<ValidatorTransaction>> {
         match &self.block_type {
             BlockType::ProposalExt(proposal_ext) => proposal_ext.validator_txns(),
-            BlockType::Proposal { .. } | BlockType::NilBlock { .. } | BlockType::Genesis => None,
+            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 +215,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 +397,35 @@ 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;

consensus/consensus-types/src/opt_block_data.rs

@@ -0,0 +1,138 @@
+// Copyright © Aptos Foundation
+// Parts of the project are originally copyright © Meta Platforms, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::{ensure, Result, bail};
+use aptos_crypto::HashValue;
+use aptos_crypto_derive::CryptoHasher;
+use aptos_infallible::duration_since_epoch;
+use aptos_types::validator_txn::ValidatorTransaction;
+use serde::{Deserialize, Serialize};
+
+use crate::{block_data::BlockType, common::{Author, Payload, Round}};
+use crate::quorum_cert::QuorumCert;
+
+#[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq, CryptoHasher)]
+/// Same as BlockData, without QC and with parent id
+pub struct OptBlockData {
+    pub epoch: u64,
+    pub round: Round,
+    pub timestamp_usecs: u64,
+    pub parent_id: HashValue,
+    pub block_type: BlockType,
+}
+
+impl OptBlockData {
+    pub fn author(&self) -> &Author {
+        match &self.block_type {
+            BlockType::OptProposal { author, .. } => author,
+            _ => panic!("Invalid block type"),
+        }
+    }
+
+    pub fn block_type(&self) -> &BlockType {
+        &self.block_type
+    }
+
+    pub fn epoch(&self) -> u64 {
+        self.epoch
+    }
+
+    pub fn parent_id(&self) -> HashValue {
+        self.parent_id
+    }
+
+    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::OptProposal { payload, .. } => Some(payload),
+            _ => panic!("Invalid block type"),
+        }
+    }
+
+    pub fn validator_txns(&self) -> Option<&Vec<ValidatorTransaction>> {
+        match &self.block_type {
+            BlockType::OptProposal { validator_txns, .. } => (!validator_txns.is_empty()).then_some(validator_txns),
+            _ => panic!("Invalid block type"),
+        }
+    }
+
+    pub fn dag_nodes(&self) -> Option<&Vec<HashValue>> {
+        if let BlockType::DAGBlock {
+            node_digests: nodes_digests,
+            ..
+        } = &self.block_type
+        {
+            Some(nodes_digests)
+        } else {
+            None
+        }
+    }
+
+    pub fn round(&self) -> Round {
+        self.round
+    }
+
+    pub fn timestamp_usecs(&self) -> u64 {
+        self.timestamp_usecs
+    }
+
+    pub fn is_opt_proposal(&self) -> bool {
+        matches!(self.block_type, BlockType::OptProposal { .. })
+    }
+
+    pub fn new_proposal(
+        validator_txns: Vec<ValidatorTransaction>,
+        payload: Payload,
+        author: Author,
+        failed_authors: Vec<(Round, Author)>,
+        epoch: u64,
+        round: Round,
+        timestamp_usecs: u64,
+        parent_id: HashValue,
+        grandparent_qc: QuorumCert,
+    ) -> Self {
+        Self {
+            epoch,
+            round,
+            timestamp_usecs,
+            parent_id,
+            block_type: BlockType::OptProposal {
+                validator_txns,
+                payload,
+                author,
+                failed_authors,
+                grandparent_qc,
+            },
+        }
+    }
+
+    pub fn verify(&self) -> Result<()> {
+        // Verifies that the OptBlockData is well-formed.
+        ensure!(
+            self.is_opt_proposal(),
+            "Only optimistic proposal is supported"
+        );
+
+        if let Some(payload) = self.payload() {
+            payload.verify_epoch(self.epoch())?;
+        }
+
+        let current_ts = duration_since_epoch();
+
+        // we can say that too far is 5 minutes in the future
+        const TIMEBOUND: u64 = 300_000_000;
+        ensure!(
+            self.timestamp_usecs() <= (current_ts.as_micros() as u64).saturating_add(TIMEBOUND),
+            "Blocks must not be too far in the future"
+        );
+
+        Ok(())
+    }
+}