refactor(sync-service): convert start_parachain to reactive state machine

lib/src/chain/blocks_tree.rs

@@ -234,6 +234,39 @@ impl<T> NonFinalizedTree<T> {
         self.blocks_trigger_gp_change.clear();
     }
 
+    /// Updates the consensus algorithm of the finalized block.
+    ///
+    /// This is useful when the chain starts with `Unknown` consensus and later
+    /// discovers the actual consensus parameters (e.g. Aura authorities).
+    ///
+    /// Non-finalized blocks that were verified under the old consensus are cleared,
+    /// as they may have been verified with incorrect rules.
+    pub fn set_finalized_consensus(
+        &mut self,
+        consensus: chain_information::ChainInformationConsensus,
+    ) {
+        self.finalized_consensus = match consensus {
+            chain_information::ChainInformationConsensus::Unknown => FinalizedConsensus::Unknown,
+            chain_information::ChainInformationConsensus::Aura {
+                finalized_authorities_list,
+                slot_duration,
+            } => FinalizedConsensus::Aura {
+                authorities_list: Arc::new(finalized_authorities_list),
+                slot_duration,
+            },
+            chain_information::ChainInformationConsensus::Babe {
+                finalized_block_epoch_information,
+                finalized_next_epoch_transition,
+                slots_per_epoch,
+            } => FinalizedConsensus::Babe {
+                slots_per_epoch,
+                block_epoch_information: finalized_block_epoch_information.map(Arc::from),
+                next_epoch_transition: Arc::from(finalized_next_epoch_transition),
+            },
+        };
+        self.clear();
+    }
+
     /// Returns true if there isn't any non-finalized block in the chain.
     pub fn is_empty(&self) -> bool {
         self.blocks.is_empty()

lib/src/sync/all.rs

@@ -243,6 +243,20 @@ impl<TRq, TSrc, TBl> AllSync<TRq, TSrc, TBl> {
         all_forks.as_chain_information()
     }
 
+    /// Updates the consensus algorithm of the finalized block in-place.
+    ///
+    /// Clears any non-finalized blocks, as they may have been verified with
+    /// incorrect consensus rules. Peers and requests are unaffected.
+    pub fn set_finalized_consensus(
+        &mut self,
+        consensus: chain_information::ChainInformationConsensus,
+    ) {
+        let Some(all_forks) = &mut self.all_forks else {
+            unreachable!()
+        };
+        all_forks.set_finalized_consensus(consensus);
+    }
+
     /// Returns the current status of the syncing.
     pub fn status(&'_ self) -> Status<'_, TSrc> {
         // TODO:

lib/src/sync/all_forks.rs

@@ -445,6 +445,16 @@ impl<TBl, TRq, TSrc> AllForksSync<TBl, TRq, TSrc> {
         self.chain.as_chain_information()
     }
 
+    /// Updates the consensus algorithm of the finalized block.
+    ///
+    /// See [`blocks_tree::NonFinalizedTree::set_finalized_consensus`] for details.
+    pub fn set_finalized_consensus(
+        &mut self,
+        consensus: chain_information::ChainInformationConsensus,
+    ) {
+        self.chain.set_finalized_consensus(consensus);
+    }
+
     /// Returns the header of the finalized block.
     pub fn finalized_block_header(&self) -> &[u8] {
         self.chain.finalized_block_header()