Fix elastic scaling support (#3141)

Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com>
Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>

Author: 3 people

lib/src/chain/blocks_tree/verify.rs

@@ -136,70 +136,78 @@ impl<T> NonFinalizedTree<T> {
             &self.finalized_block_header
         };
 
-        let header_verify_result = {
-            let consensus_config = match (&self.finalized_consensus, &parent_consensus) {
-                (
-                    FinalizedConsensus::Aura { slot_duration, .. },
-                    Some(BlockConsensus::Aura { authorities_list }),
-                ) => verify::header_only::ConfigConsensus::Aura {
-                    current_authorities: header::AuraAuthoritiesIter::from_slice(authorities_list),
-                    now_from_unix_epoch,
-                    slot_duration: *slot_duration,
-                },
-                (
-                    FinalizedConsensus::Babe {
-                        slots_per_epoch, ..
+        let (best_score_num_primary_slots, best_score_num_secondary_slots, consensus_update) = {
+            let header_verify_result = {
+                let consensus_config = match (&self.finalized_consensus, &parent_consensus) {
+                    (
+                        FinalizedConsensus::Aura { slot_duration, .. },
+                        Some(BlockConsensus::Aura { authorities_list }),
+                    ) => verify::header_only::ConfigConsensus::Aura {
+                        current_authorities: header::AuraAuthoritiesIter::from_slice(
+                            authorities_list,
+                        ),
+                        now_from_unix_epoch,
+                        slot_duration: *slot_duration,
+                        // Parachains with async backing can produce multiple blocks per
+                        // Aura slot. Outsourced finality indicates a parachain.
+                        allow_equal_slot_number: matches!(self.finality, Finality::Outsourced),
                     },
-                    Some(BlockConsensus::Babe {
-                        current_epoch,
-                        next_epoch,
-                    }),
-                ) => verify::header_only::ConfigConsensus::Babe {
-                    parent_block_epoch: current_epoch.as_ref().map(|v| (&**v).into()),
-                    parent_block_next_epoch: (&**next_epoch).into(),
-                    slots_per_epoch: *slots_per_epoch,
-                    now_from_unix_epoch,
-                },
-                (FinalizedConsensus::Unknown, None) => {
-                    return Err(HeaderVerifyError::UnknownConsensusEngine);
-                }
-                _ => {
-                    return Err(HeaderVerifyError::ConsensusMismatch);
-                }
-            };
+                    (
+                        FinalizedConsensus::Babe {
+                            slots_per_epoch, ..
+                        },
+                        Some(BlockConsensus::Babe {
+                            current_epoch,
+                            next_epoch,
+                        }),
+                    ) => verify::header_only::ConfigConsensus::Babe {
+                        parent_block_epoch: current_epoch.as_ref().map(|v| (&**v).into()),
+                        parent_block_next_epoch: (&**next_epoch).into(),
+                        slots_per_epoch: *slots_per_epoch,
+                        now_from_unix_epoch,
+                    },
+                    (FinalizedConsensus::Unknown, None) => {
+                        return Err(HeaderVerifyError::UnknownConsensusEngine);
+                    }
+                    _ => {
+                        return Err(HeaderVerifyError::ConsensusMismatch);
+                    }
+                };
 
-            match verify::header_only::verify(verify::header_only::Config {
-                consensus: consensus_config,
-                finality: match &parent_finality {
-                    BlockFinality::Outsourced => verify::header_only::ConfigFinality::Outsourced,
-                    BlockFinality::Grandpa { .. } => verify::header_only::ConfigFinality::Grandpa,
-                },
-                allow_unknown_consensus_engines: self.allow_unknown_consensus_engines,
-                block_header: decoded_header.clone(),
-                block_number_bytes: self.block_number_bytes,
-                parent_block_header: {
-                    // All headers inserted in `self` are necessarily valid, and thus this
-                    // `unwrap()` can't panic.
-                    header::decode(parent_block_header, self.block_number_bytes)
-                        .unwrap_or_else(|_| unreachable!())
-                },
-            }) {
-                Ok(s) => s,
-                Err(err) => {
-                    // The code in this module is meant to ensure that the chain is in an
-                    // appropriate state, therefore `is_invalid_chain_configuration` being `true`
-                    // would indicate a bug in the code somewhere.
-                    // We use a `debug_assert` rather than `assert` in order to avoid crashing,
-                    // as treating the header as invalid is an appropriate way to handle a bug
-                    // here.
-                    debug_assert!(!err.is_invalid_chain_configuration());
-                    return Err(HeaderVerifyError::VerificationFailed(err));
+                match verify::header_only::verify(verify::header_only::Config {
+                    consensus: consensus_config,
+                    finality: match &parent_finality {
+                        BlockFinality::Outsourced => {
+                            verify::header_only::ConfigFinality::Outsourced
+                        }
+                        BlockFinality::Grandpa { .. } => {
+                            verify::header_only::ConfigFinality::Grandpa
+                        }
+                    },
+                    allow_unknown_consensus_engines: self.allow_unknown_consensus_engines,
+                    block_header: decoded_header.clone(),
+                    block_number_bytes: self.block_number_bytes,
+                    parent_block_header: {
+                        // All headers inserted in `self` are necessarily valid, and thus this
+                        // `unwrap()` can't panic.
+                        header::decode(parent_block_header, self.block_number_bytes)
+                            .unwrap_or_else(|_| unreachable!())
+                    },
+                }) {
+                    Ok(s) => s,
+                    Err(err) => {
+                        // The code in this module is meant to ensure that the chain is in an
+                        // appropriate state, therefore `is_invalid_chain_configuration` being `true`
+                        // would indicate a bug in the code somewhere.
+                        // We use a `debug_assert` rather than `assert` in order to avoid crashing,
+                        // as treating the header as invalid is an appropriate way to handle a bug
+                        // here.
+                        debug_assert!(!err.is_invalid_chain_configuration());
+                        return Err(HeaderVerifyError::VerificationFailed(err));
+                    }
                 }
-            }
-        };
+            };
 
-        // Updated consensus information for the block being verified.
-        let (best_score_num_primary_slots, best_score_num_secondary_slots, consensus_update) =
             match (
                 header_verify_result,
                 &parent_consensus,
@@ -358,10 +366,11 @@ impl<T> NonFinalizedTree<T> {
                     )
                 }
 
-                // Any mismatch between consensus algorithms should have been detected by the
-                // block verification.
+                // Any mismatch between consensus algorithms should have been detected by
+                // the block verification.
                 _ => unreachable!(),
-            };
+            }
+        };
 
         // Updated finality information for the block being verified.
         let finality_update = match &parent_finality {

lib/src/sync/all.rs

@@ -307,6 +307,41 @@ impl<TRq, TSrc, TBl> AllSync<TRq, TSrc, TBl> {
         all_forks.finalized_block_hash()
     }
 
+    /// Updates the finalized block to the given `block_hash`.
+    ///
+    /// This should be used when the finality is outsourced.
+    pub fn set_finalized_block(
+        &mut self,
+        block_hash: &[u8; 32],
+    ) -> Result<SetFinalizedBlockResult<TBl>, SetFinalizedBlockError> {
+        let Some(all_forks) = self.all_forks.as_mut() else {
+            unreachable!()
+        };
+
+        let result = all_forks
+            .set_finalized_block(block_hash)
+            .map_err(|_| SetFinalizedBlockError::UnknownBlock)?;
+
+        Ok(SetFinalizedBlockResult {
+            finalized_blocks: result
+                .finalized_blocks
+                .into_iter()
+                .map(|b| Block {
+                    header: b.scale_encoded_header,
+                    block_hash: b.block_hash,
+                    // Should be always `Some`.
+                    user_data: b.user_data.unwrap(),
+                })
+                .collect(),
+            pruned_blocks: result
+                .pruned_blocks
+                .into_iter()
+                .map(|b| b.block_hash)
+                .collect(),
+            updates_best_block: result.updates_best_block,
+        })
+    }
+
     /// Returns the header of the best block.
     ///
     /// > **Note**: This value is provided only for informative purposes. Keep in mind that this
@@ -737,7 +772,7 @@ impl<TRq, TSrc, TBl> AllSync<TRq, TSrc, TBl> {
                 num_blocks,
                 request_headers: true,
                 request_bodies,
-                request_justification: true,
+                request_justification: _,
             } if request_bodies || !self.shared.download_bodies => {
                 let Some(all_forks) = &mut self.all_forks else {
                     unreachable!()
@@ -2292,6 +2327,22 @@ pub enum FinalityProofVerifyOutcome<TBl> {
     GrandpaCommitError(CommitVerifyError),
 }
 
+/// Returned by [`AllSync::set_finalized_block`].
+pub struct SetFinalizedBlockResult<TBl> {
+    /// The finalized blocks.
+    pub finalized_blocks: Vec<Block<TBl>>,
+    /// The blocks that got pruned while finalizing.
+    pub pruned_blocks: Vec<[u8; 32]>,
+    /// Is set to `true`, if the best block changed.
+    pub updates_best_block: bool,
+}
+
+/// Potential error returned by [`AllSync::set_finalized_block`].
+#[derive(Debug, derive_more::Display)]
+pub enum SetFinalizedBlockError {
+    UnknownBlock,
+}
+
 pub struct WarpSyncFragmentVerify<TRq, TSrc, TBl> {
     inner: warp_sync::VerifyWarpSyncFragment<WarpSyncSourceExtra, WarpSyncRequestExtra>,
     ready_to_transition: Option<warp_sync::RuntimeInformation>,

lib/src/sync/all_forks.rs

@@ -460,6 +460,49 @@ impl<TBl, TRq, TSrc> AllForksSync<TBl, TRq, TSrc> {
         self.chain.finalized_block_hash()
     }
 
+    /// Updates the finalized block to the given `block_hash`.
+    ///
+    /// This should be used when the finality is outsourced.
+    pub fn set_finalized_block(
+        &mut self,
+        block_hash: &[u8; 32],
+    ) -> Result<SetFinalizedBlockResult<TBl>, blocks_tree::SetFinalizedError> {
+        let iter = self.chain.set_finalized_block(block_hash)?;
+        let updates_best_block = iter.updates_best_block();
+        let mut finalized_blocks = Vec::new();
+        let mut pruned_blocks = Vec::new();
+        for block in iter {
+            match block.ty {
+                blocks_tree::RemovedBlockType::Finalized => finalized_blocks.push(RemovedBlock {
+                    block_hash: block.block_hash,
+                    block_number: block.block_number,
+                    user_data: block.user_data,
+                    scale_encoded_header: block.scale_encoded_header,
+                }),
+                blocks_tree::RemovedBlockType::Pruned => pruned_blocks.push(RemovedBlock {
+                    block_hash: block.block_hash,
+                    block_number: block.block_number,
+                    user_data: block.user_data,
+                    scale_encoded_header: block.scale_encoded_header,
+                }),
+            }
+        }
+
+        if let Some(last) = finalized_blocks.last() {
+            let _ = self
+                .inner
+                .blocks
+                .set_finalized_block_height(last.block_number)
+                .count();
+        }
+
+        Ok(SetFinalizedBlockResult {
+            finalized_blocks,
+            pruned_blocks,
+            updates_best_block,
+        })
+    }
+
     /// Returns the header of the best block.
     ///
     /// > **Note**: This value is provided only for informative purposes. Keep in mind that this
@@ -2385,3 +2428,13 @@ pub struct RemovedBlock<TBl> {
     /// SCALE-encoded header of the block.
     pub scale_encoded_header: Vec<u8>,
 }
+
+/// Result of [`AllForksSync::set_finalized_block`].
+pub struct SetFinalizedBlockResult<TBl> {
+    /// The blocks that got finalized.
+    pub finalized_blocks: Vec<RemovedBlock<TBl>>,
+    /// The blocks that got pruned in the process of finalizing.
+    pub pruned_blocks: Vec<RemovedBlock<TBl>>,
+    /// Is set to `true`, if the best block changed.
+    pub updates_best_block: bool,
+}

lib/src/verify/aura.rs

@@ -78,6 +78,11 @@ pub struct VerifyConfig<'a, TAuthList> {
     /// Duration of a slot in milliseconds.
     /// Can be found by calling the `AuraApi_slot_duration` runtime function.
     pub slot_duration: NonZero<u64>,
+
+    /// If `true`, allow the slot number to be equal to the parent's slot number.
+    ///
+    /// This is required for parachains which can produce multiple blocks per slot.
+    pub allow_equal_slot_number: bool,
 }
 
 /// Information yielded back after successfully verifying a block.
@@ -132,7 +137,11 @@ pub fn verify_header<'a>(
             None => return Err(VerifyError::ParentIsntAuraConsensus),
         };
 
-        if slot_number <= parent_slot_number {
+        if config.allow_equal_slot_number {
+            if slot_number < parent_slot_number {
+                return Err(VerifyError::SlotNumberNotIncreasing);
+            }
+        } else if slot_number <= parent_slot_number {
             return Err(VerifyError::SlotNumberNotIncreasing);
         }
     }
@@ -171,18 +180,13 @@ pub fn verify_header<'a>(
 
     // The signature in the seal applies to the header from where the signature isn't present.
     // Extract the signature and build the hash that is expected to be signed.
-    let (seal_signature, pre_seal_hash) = {
+    let (seal_bytes, pre_seal_hash) = {
         let mut unsealed_header = config.header;
-        let seal_signature = match unsealed_header.digest.pop_seal() {
-            Some(header::Seal::Aura(seal)) => {
-                schnorrkel::Signature::from_bytes(seal).map_err(|_| VerifyError::BadSignature)?
-            }
+        let seal_bytes: [u8; 64] = match unsealed_header.digest.pop_seal() {
+            Some(header::Seal::Aura(seal)) => *seal,
             _ => return Err(VerifyError::MissingSeal),
         };
-        (
-            seal_signature,
-            unsealed_header.hash(config.block_number_bytes),
-        )
+        (seal_bytes, unsealed_header.hash(config.block_number_bytes))
     };
 
     // Fetch the authority that has supposedly signed the block.
@@ -200,21 +204,29 @@ pub fn verify_header<'a>(
     )
     .unwrap_or_else(|_| unreachable!());
 
-    // This `unwrap()` can only panic if `public_key` is the wrong length, which we know can't
-    // happen as it's of type `[u8; 32]`.
-    let authority_public_key = schnorrkel::PublicKey::from_bytes(
-        config
-            .current_authorities
-            .nth(signing_authority)
-            .unwrap()
-            .public_key,
-    )
-    .unwrap();
-
-    // Now verifying the signature in the seal.
-    authority_public_key
-        .verify_simple(b"substrate", &pre_seal_hash, &seal_signature)
-        .map_err(|_| VerifyError::BadSignature)?;
+    let authority_public_key = config
+        .current_authorities
+        .nth(signing_authority)
+        .unwrap()
+        .public_key;
+
+    // Try sr25519 verification first, then fall back to ed25519.
+    let sr25519_ok = schnorrkel::PublicKey::from_bytes(authority_public_key)
+        .and_then(|pk| {
+            pk.verify_simple(
+                b"substrate",
+                &pre_seal_hash,
+                &schnorrkel::Signature::from_bytes(&seal_bytes)?,
+            )
+        })
+        .is_ok();
+
+    if !sr25519_ok {
+        ed25519_zebra::VerificationKey::try_from(*authority_public_key)
+            .map_err(|_| VerifyError::BadSignature)?
+            .verify(&ed25519_zebra::Signature::from(seal_bytes), &pre_seal_hash)
+            .map_err(|_| VerifyError::BadSignature)?;
+    }
 
     // Success! 🚀
     Ok(VerifySuccess { authorities_change })