create local network

update the autobootstrap to waypoint version

Author: Bo Wu

Cargo.lock

@@ -363,7 +363,7 @@ impl Default for ConsensusConfig {
             max_pending_rounds_in_commit_vote_cache: 100,
             optimistic_sig_verification: true,
             enable_round_timeout_msg: true,
-            enable_pipeline: true,
+            enable_pipeline: false,
         }
     }
 }

config/src/config/consensus_config.rs

@@ -177,7 +177,11 @@ impl Block {
     /// Construct new genesis block for next epoch deterministically from the end-epoch LedgerInfo
     /// We carry over most fields except round and block id
     pub fn make_genesis_block_from_ledger_info(ledger_info: &LedgerInfo) -> Self {
-        let block_data = BlockData::new_genesis_from_ledger_info(ledger_info);
+        let block_data = if ledger_info.ends_epoch() {
+            BlockData::new_genesis_from_ledger_info(ledger_info)
+        } else {
+            BlockData::make_genesis_block_from_any_ledger_info(ledger_info)
+        };
         Block {
             id: block_data.hash(),
             block_data,

consensus/consensus-types/src/block.rs

@@ -188,6 +188,22 @@ impl BlockData {
         }
     }
 
+    pub fn make_genesis_block_from_any_ledger_info(ledger_info: &LedgerInfo) -> Self {
+        let ancestor = ledger_info.commit_info().to_owned();
+
+        // Genesis carries a placeholder quorum certificate to its parent id with LedgerInfo
+        // carrying information about version from the last LedgerInfo of previous epoch.
+        let genesis_quorum_cert = QuorumCert::new(
+            VoteData::new(ancestor.clone(), ancestor.clone()),
+            LedgerInfoWithSignatures::new(
+                LedgerInfo::new(ancestor, HashValue::zero()),
+                AggregateSignature::empty(),
+            ),
+        );
+
+        BlockData::new_starting_block(ledger_info.timestamp_usecs(), genesis_quorum_cert)
+    }
+
     pub fn new_genesis_from_ledger_info(ledger_info: &LedgerInfo) -> Self {
         assert!(ledger_info.ends_epoch());
         let ancestor = BlockInfo::new(
@@ -246,9 +262,22 @@ impl BlockData {
 
     #[allow(unexpected_cfgs)]
     pub fn new_genesis(timestamp_usecs: u64, quorum_cert: QuorumCert) -> Self {
+        assume!(quorum_cert.certified_block().epoch() < u64::MAX); // unlikely to be false in this universe
+        let genesis_epoch = quorum_cert.certified_block().epoch() + 1;
+        Self {
+            epoch: genesis_epoch,
+            round: 0,
+            timestamp_usecs,
+            quorum_cert,
+            block_type: BlockType::Genesis,
+        }
+    }
+
+    #[allow(unexpected_cfgs)]
+    pub fn new_starting_block(timestamp_usecs: u64, quorum_cert: QuorumCert) -> Self {
         assume!(quorum_cert.certified_block().epoch() < u64::MAX); // unlikely to be false in this universe
         Self {
-            epoch: quorum_cert.certified_block().epoch() + 1,
+            epoch: quorum_cert.certified_block().epoch(),
             round: 0,
             timestamp_usecs,
             quorum_cert,

consensus/consensus-types/src/block_data.rs

@@ -571,15 +571,16 @@ impl PipelinedBlock {
     }
 
     pub async fn wait_for_compute_result(&self) -> ExecutorResult<(StateComputeResult, Duration)> {
-        self.pipeline_futs()
-            .ok_or(ExecutorError::InternalError {
-                error: "Pipeline aborted".to_string(),
-            })?
+        let pipeline_futs = self.pipeline_futs().ok_or(ExecutorError::InternalError {
+            error: "Pipeline aborted".to_string(),
+        })?;
+
+        pipeline_futs
             .ledger_update_fut
             .await
             .map(|(compute_result, execution_time, _)| (compute_result, execution_time))
             .map_err(|e| ExecutorError::InternalError {
-                error: e.to_string(),
+                error: e.to_string()
             })
     }
 

consensus/consensus-types/src/pipelined_block.rs

@@ -82,31 +82,51 @@ impl QuorumCert {
     /// - the accumulator root hash of the LedgerInfo is set to the last executed state of previous
     ///   epoch.
     /// - the map of signatures is empty because genesis block is implicitly agreed.
+    // TODO(l1-migration): This is for recovery when we lost consensu DB data
+    // We create this virual block and don't want to add 1 since it is not epoch_ending block
+
     pub fn certificate_for_genesis_from_ledger_info(
         ledger_info: &LedgerInfo,
         genesis_id: HashValue,
     ) -> QuorumCert {
-        let ancestor = BlockInfo::new(
+        let ancestor_epoch = if ledger_info.ends_epoch() {
             ledger_info
                 .epoch()
                 .checked_add(1)
-                .expect("Integer overflow when creating cert for genesis from ledger info"),
-            0,
-            genesis_id,
-            ledger_info.transaction_accumulator_hash(),
-            ledger_info.version(),
-            ledger_info.timestamp_usecs(),
-            None,
-        );
+                .expect("Integer overflow when creating cert for genesis from ledger info")
+        } else {
+            ledger_info.epoch()
+        };
+
+        let ancestor = if ledger_info.ends_epoch() {
+            BlockInfo::new(
+                ancestor_epoch,
+                0,
+                genesis_id,
+                ledger_info.transaction_accumulator_hash(),
+                ledger_info.version(),
+                ledger_info.timestamp_usecs(),
+                None,
+            )
+        } else {
+            BlockInfo::new(
+                ancestor_epoch,
+                0,
+                genesis_id,
+                ledger_info.transaction_accumulator_hash(),
+                ledger_info.version(),
+                ledger_info.timestamp_usecs(),
+                None,
+            )
+        };
 
         let vote_data = VoteData::new(ancestor.clone(), ancestor.clone());
         let li = LedgerInfo::new(ancestor, vote_data.hash());
 
         let validator_set_size = ledger_info
             .next_epoch_state()
-            .expect("Next epoch state not found in ledger info")
-            .verifier
-            .len();
+            .map(|epoch_state| epoch_state.verifier.len())
+            .unwrap_or(1);
 
         QuorumCert::new(
             vote_data,

consensus/consensus-types/src/quorum_cert.rs

@@ -131,6 +131,7 @@ impl SafetyRules {
         let mut updated = false;
         let one_chain = qc.certified_block().round();
         let two_chain = qc.parent_block().round();
+
         if one_chain > safety_data.one_chain_round {
             safety_data.one_chain_round = one_chain;
             trace!(
@@ -260,6 +261,7 @@ impl SafetyRules {
         let last_li = proof
             .verify(&waypoint)
             .map_err(|e| Error::InvalidEpochChangeProof(format!("{}", e)))?;
+
         let ledger_info = last_li.ledger_info();
         let epoch_state = ledger_info
             .next_epoch_state()

consensus/safety-rules/src/safety_rules.rs

@@ -311,6 +311,9 @@ impl BlockStore {
         let block_to_commit = self
             .get_block(block_id_to_commit)
             .ok_or_else(|| format_err!("Committed block id not found"))?;
+        if block_to_commit.block().is_genesis_block() && block_to_commit.round() == 0 {
+            return Ok(());
+        }
 
         // First make sure that this commit is new.
         ensure!(

consensus/src/block_storage/block_store.rs

@@ -1476,9 +1476,10 @@ impl<P: OnChainConfigProvider> EpochManager<P> {
         tokio::spawn(bootstrapper.start(dag_rpc_rx, dag_shutdown_rx));
     }
 
+    //TODO(l1-migration) turn on quorum store
     fn enable_quorum_store(&mut self, onchain_config: &OnChainConsensusConfig) -> bool {
         fail_point!("consensus::start_new_epoch::disable_qs", |_| false);
-        onchain_config.quorum_store_enabled()
+        onchain_config.quorum_store_enabled() && false
     }
 
     async fn process_message(

consensus/src/epoch_manager.rs

@@ -288,6 +288,7 @@ impl ExecutionPipeline {
         {
             counters::APPLY_LEDGER_WAIT_TIME.observe_duration(command_creation_time.elapsed());
             debug!("ledger_apply stage received block {}.", block_id);
+
             let res = async {
                 let execution_duration = execution_time?;
                 let executor = executor.clone();