diff --git a/cumulus/client/consensus/aura/src/collators/mod.rs b/cumulus/client/consensus/aura/src/collators/mod.rs index b4036544c4561..bbe2c9b0b1764 100644 --- a/cumulus/client/consensus/aura/src/collators/mod.rs +++ b/cumulus/client/consensus/aura/src/collators/mod.rs @@ -43,19 +43,6 @@ pub mod basic; pub mod lookahead; pub mod slot_based; -// This is an arbitrary value which is guaranteed to exceed the required depth for 500ms blocks -// built with a relay parent offset of 1. It must be larger than the unincluded segment capacity. -// -// The formula we use to compute the capacity of the unincluded segment in the parachain runtime -// is: -// UNINCLUDED_SEGMENT_CAPACITY = (2 + RELAY_PARENT_OFFSET) * BLOCK_PROCESSING_VELOCITY + 1. -// -// Since we only search for parent blocks which have already been imported, -// we can guarantee that all imported blocks respect the unincluded segment -// rules specified by the parachain's runtime and thus will never be too deep. This is just an extra -// sanity check. -const PARENT_SEARCH_DEPTH: usize = 40; - // Helper to pre-connect to the backing group we got assigned to and keep the connection // open until backing group changes or own slot ends. struct BackingGroupConnectionHelper { @@ -286,7 +273,6 @@ where .await .unwrap_or(DEFAULT_SCHEDULING_LOOKAHEAD) .saturating_sub(1) as usize, - max_depth: PARENT_SEARCH_DEPTH, ignore_alternative_branches: true, }; diff --git a/cumulus/client/consensus/common/src/parent_search.rs b/cumulus/client/consensus/common/src/parent_search.rs index 90e044899cce5..078383c067193 100644 --- a/cumulus/client/consensus/common/src/parent_search.rs +++ b/cumulus/client/consensus/common/src/parent_search.rs @@ -42,9 +42,6 @@ pub struct ParentSearchParams { /// A limitation on the age of relay parents for parachain blocks that are being /// considered. This is relative to the `relay_parent` number. pub ancestry_lookback: usize, - /// How "deep" parents can be relative to the included parachain block at the relay-parent. - /// The included block has depth 0. - pub max_depth: usize, /// Whether to only ignore "alternative" branches, i.e. branches of the chain /// which do not contain the block pending availability. pub ignore_alternative_branches: bool, @@ -78,18 +75,17 @@ impl std::fmt::Debug for PotentialParent { /// Perform a recursive search through blocks to find potential /// parent blocks for a new block. /// -/// This accepts a relay-chain block to be used as an anchor and a maximum search depth, -/// along with some arguments for filtering parachain blocks and performs a recursive search -/// for parachain blocks. The search begins at the last included parachain block and returns -/// a set of [`PotentialParent`]s which could be potential parents of a new block with this +/// This accepts a relay-chain block to be used as an anchor along with some arguments for +/// filtering parachain blocks and performs a recursive search for parachain blocks. +/// The search begins at the last included parachain block and returns a set of +/// [`PotentialParent`]s which could be potential parents of a new block with this /// relay-parent according to the search parameters. /// /// A parachain block is a potential parent if it is either the last included parachain block, the -/// pending parachain block (when `max_depth` >= 1), or all of the following hold: +/// pending parachain block, or all of the following hold: /// * its parent is a potential parent /// * its relay-parent is within `ancestry_lookback` of the targeted relay-parent. /// * its relay-parent is within the same session as the targeted relay-parent. -/// * the block number is within `max_depth` blocks of the included block pub async fn find_potential_parents( params: ParentSearchParams, backend: &impl Backend, @@ -111,10 +107,6 @@ pub async fn find_potential_parents( aligned_with_pending: true, }]; - if params.max_depth == 0 { - return Ok(only_included); - }; - // Pending header and hash. let maybe_pending = { // Fetch the most recent pending header from the relay chain. We use @@ -161,7 +153,7 @@ pub async fn find_potential_parents( // If we want to ignore alternative branches there is no reason to start // the parent search at the included block. We can add the included block and - // the path to the pending block to the potential parents directly (limited by max_depth). + // the path to the pending block to the potential parents directly. let (frontier, potential_parents) = match ( &maybe_pending, params.ignore_alternative_branches, @@ -176,10 +168,8 @@ pub async fn find_potential_parents( return Ok(Default::default()); } - // Add all items on the path included -> pending - 1 to the potential parents, but - // not more than `max_depth`. - let num_parents_on_path = - route_to_pending.enacted().len().saturating_sub(1).min(params.max_depth); + // Add all items on the path included -> pending - 1 to the potential parents. + let num_parents_on_path = route_to_pending.enacted().len().saturating_sub(1); for (num, block) in route_to_pending.enacted().iter().take(num_parents_on_path).enumerate() { @@ -208,10 +198,6 @@ pub async fn find_potential_parents( _ => (only_included, Default::default()), }; - if potential_parents.len() > params.max_depth { - return Ok(potential_parents); - } - // Build up the ancestry record of the relay chain to compare against. let rp_ancestry = build_relay_parent_ancestry(params.ancestry_lookback, params.relay_parent, relay_client) @@ -223,7 +209,6 @@ pub async fn find_potential_parents( included_header, maybe_pending.map(|(_, hash)| hash), backend, - params.max_depth, params.ignore_alternative_branches, rp_ancestry, potential_parents, @@ -323,7 +308,6 @@ pub fn search_child_branches_for_parents( included_header: Block::Header, pending_hash: Option, backend: &impl Backend, - max_depth: usize, ignore_alternative_branches: bool, rp_ancestry: Vec<(RelayHash, RelayHash)>, mut potential_parents: Vec>, @@ -355,7 +339,7 @@ pub fn search_child_branches_for_parents( let is_pending = pending_hash.as_ref().map_or(false, |h| &entry.hash == h); let is_included = included_hash == entry.hash; - // note: even if the pending block or included block have a relay parent + // Note: even if the pending block or included block have a relay parent // outside of the expected part of the relay chain, they are always allowed // because they have already been posted on chain. let is_potential = is_pending || is_included || { @@ -385,13 +369,11 @@ pub fn search_child_branches_for_parents( if is_potential { potential_parents.push(entry); - } - - if !is_potential || child_depth > max_depth { + } else { continue; } - // push children onto search frontier. + // Push children onto search frontier. for child in backend.blockchain().children(hash).ok().into_iter().flatten() { tracing::trace!(target: PARENT_SEARCH_LOG_TARGET, ?child, child_depth, ?pending_distance, "Looking at child."); diff --git a/cumulus/client/consensus/common/src/tests.rs b/cumulus/client/consensus/common/src/tests.rs index afd4bec7d3487..3434a2fedc46d 100644 --- a/cumulus/client/consensus/common/src/tests.rs +++ b/cumulus/client/consensus/common/src/tests.rs @@ -986,7 +986,6 @@ fn find_potential_parents_in_allowed_ancestry() { relay_parent, para_id: ParaId::from(100), ancestry_lookback: 0, - max_depth: 0, ignore_alternative_branches: true, }, &*backend, @@ -1022,7 +1021,6 @@ fn find_potential_parents_in_allowed_ancestry() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 2, - max_depth: 1, ignore_alternative_branches: true, }, &*backend, @@ -1044,7 +1042,6 @@ fn find_potential_parents_in_allowed_ancestry() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 1, - max_depth: 1, ignore_alternative_branches: true, }, &*backend, @@ -1103,7 +1100,6 @@ fn find_potential_pending_parent() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 0, - max_depth: 1, ignore_alternative_branches: true, }, &*backend, @@ -1126,83 +1122,10 @@ fn find_potential_pending_parent() { assert!(pending_parent.aligned_with_pending); } -#[test] -fn find_potential_parents_with_max_depth() { - sp_tracing::try_init_simple(); - - const NON_INCLUDED_CHAIN_LEN: usize = 5; - - let backend = Arc::new(Backend::new_test(1000, 1)); - let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); - let mut para_import = ParachainBlockImport::new(client.clone(), backend.clone()); - - let relay_parent = relay_hash_from_block_num(10); - let included_block = build_and_import_block_ext( - &client, - BlockOrigin::Own, - true, - &mut para_import, - None, - None, - Some(relay_parent), - ); - - let relay_chain = Relaychain::new(); - { - let included_map = &mut relay_chain.inner.lock().unwrap().relay_chain_hash_to_header; - included_map.insert(relay_parent, included_block.header().clone()); - } - - let mut blocks = Vec::new(); - let mut parent = included_block.header().hash(); - for _ in 0..NON_INCLUDED_CHAIN_LEN { - let block = build_and_import_block_ext( - &client, - BlockOrigin::Own, - true, - &mut para_import, - Some(parent), - None, - Some(relay_parent), - ); - parent = block.header().hash(); - blocks.push(block); - } - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 0, - max_depth, - ignore_alternative_branches: true, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - assert_eq!(potential_parents.len(), max_depth + 1); - let expected_parents: Vec<_> = - std::iter::once(&included_block).chain(blocks.iter().take(max_depth)).collect(); - - for i in 0..(max_depth + 1) { - let parent = &potential_parents[i]; - let expected = &expected_parents[i]; - - assert_eq!(parent.hash, expected.hash()); - assert_eq!(&parent.header, expected.header()); - assert_eq!(parent.depth, i); - assert!(parent.aligned_with_pending); - } - } -} - #[test] fn find_potential_parents_unknown_included() { sp_tracing::try_init_simple(); - const NON_INCLUDED_CHAIN_LEN: usize = 5; - let backend = Arc::new(Backend::new_test(1000, 1)); let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); let relay_parent = relay_hash_from_block_num(10); @@ -1226,7 +1149,6 @@ fn find_potential_parents_unknown_included() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth: NON_INCLUDED_CHAIN_LEN, ignore_alternative_branches: true, }, &*backend, @@ -1241,8 +1163,6 @@ fn find_potential_parents_unknown_included() { fn find_potential_parents_unknown_pending() { sp_tracing::try_init_simple(); - const NON_INCLUDED_CHAIN_LEN: usize = 5; - let backend = Arc::new(Backend::new_test(1000, 1)); let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); let mut para_import = @@ -1287,7 +1207,6 @@ fn find_potential_parents_unknown_pending() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth: NON_INCLUDED_CHAIN_LEN, ignore_alternative_branches: true, }, &*backend, @@ -1302,8 +1221,6 @@ fn find_potential_parents_unknown_pending() { fn find_potential_parents_unknown_pending_include_alternative_branches() { sp_tracing::try_init_simple(); - const NON_INCLUDED_CHAIN_LEN: usize = 5; - let backend = Arc::new(Backend::new_test(1000, 1)); let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); let mut para_import = @@ -1361,7 +1278,6 @@ fn find_potential_parents_unknown_pending_include_alternative_branches() { relay_parent: search_relay_parent, para_id: ParaId::from(100), ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth: NON_INCLUDED_CHAIN_LEN, ignore_alternative_branches: false, }, &*backend, @@ -1470,81 +1386,65 @@ fn find_potential_parents_aligned_with_late_pending() { } // Ignore alternative branch: - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth, - ignore_alternative_branches: true, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - - assert_eq!(potential_parents.len(), max_depth + 1); - let expected_parents: Vec<_> = [&included_block, &in_between_block, &pending_block] - .into_iter() - .chain(aligned_blocks.iter()) - .take(max_depth + 1) - .collect(); - - for i in 0..(max_depth + 1) { - let parent = &potential_parents[i]; - let expected = &expected_parents[i]; - - assert_eq!(parent.hash, expected.hash()); - assert_eq!(&parent.header, expected.header()); - assert_eq!(parent.depth, i); - assert!(parent.aligned_with_pending); - } + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_parents: Vec<_> = [&included_block, &in_between_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .collect(); + + assert_eq!(potential_parents.len(), expected_parents.len()); + for (i, (parent, expected)) in potential_parents.iter().zip(expected_parents.iter()).enumerate() + { + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + assert_eq!(parent.depth, i); + assert!(parent.aligned_with_pending); } // Do not ignore: - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth, - ignore_alternative_branches: false, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - - let expected_len = 2 * max_depth + 1; - assert_eq!(potential_parents.len(), expected_len); - let expected_aligned: Vec<_> = [&included_block, &in_between_block, &pending_block] - .into_iter() - .chain(aligned_blocks.iter()) - .take(max_depth + 1) - .collect(); - let expected_alt = alt_blocks.iter().take(max_depth); - - let expected_parents: Vec<_> = - expected_aligned.clone().into_iter().chain(expected_alt).collect(); - // Check correctness. - assert_eq!(expected_parents.len(), expected_len); - - for i in 0..expected_len { - let parent = &potential_parents[i]; - let expected = expected_parents - .iter() - .find(|block| block.header().hash() == parent.hash) - .expect("missing parent"); - - let is_aligned = expected_aligned.contains(&expected); - - assert_eq!(parent.hash, expected.hash()); - assert_eq!(&parent.header, expected.header()); - - assert_eq!(parent.aligned_with_pending, is_aligned); - } + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: false, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_aligned: Vec<_> = [&included_block, &in_between_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .collect(); + + let expected_parents: Vec<_> = + expected_aligned.clone().into_iter().chain(alt_blocks.iter()).collect(); + + assert_eq!(potential_parents.len(), expected_parents.len()); + for parent in potential_parents.iter() { + let expected = expected_parents + .iter() + .find(|block| block.header().hash() == parent.hash) + .expect("missing parent"); + + let is_aligned = expected_aligned.contains(&expected); + + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + assert_eq!(parent.aligned_with_pending, is_aligned); } } @@ -1626,88 +1526,65 @@ fn find_potential_parents_aligned_with_pending() { } // Ignore alternative branch: - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth, - ignore_alternative_branches: true, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - assert_eq!(potential_parents.len(), max_depth + 1); - let expected_parents: Vec<_> = [&included_block, &pending_block] - .into_iter() - .chain(aligned_blocks.iter()) - .take(max_depth + 1) - .collect(); - - for i in 0..(max_depth + 1) { - let parent = &potential_parents[i]; - let expected = &expected_parents[i]; - - assert_eq!(parent.hash, expected.hash()); - assert_eq!(&parent.header, expected.header()); - assert_eq!(parent.depth, i); - assert!(parent.aligned_with_pending); - } + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_parents: Vec<_> = [&included_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .collect(); + + assert_eq!(potential_parents.len(), expected_parents.len()); + for (i, (parent, expected)) in potential_parents.iter().zip(expected_parents.iter()).enumerate() + { + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + assert_eq!(parent.depth, i); + assert!(parent.aligned_with_pending); } // Do not ignore: - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - log::info!("Ran with max_depth = {max_depth}"); - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth, - ignore_alternative_branches: false, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - - let expected_len = 2 * max_depth + 1; - assert_eq!(potential_parents.len(), expected_len); - let expected_aligned: Vec<_> = [&included_block, &pending_block] - .into_iter() - .chain(aligned_blocks.iter()) - .take(max_depth + 1) - .collect(); - let expected_alt = alt_blocks.iter().take(max_depth); - - let expected_parents: Vec<_> = - expected_aligned.clone().into_iter().chain(expected_alt).collect(); - // Check correctness. - assert_eq!(expected_parents.len(), expected_len); - - potential_parents.iter().for_each(|p| log::info!("result: {:?}", p)); - for i in 0..expected_len { - let parent = &potential_parents[i]; - let expected = expected_parents - .iter() - .find(|block| block.header().hash() == parent.hash) - .expect("missing parent"); - - let is_aligned = expected_aligned.contains(&expected); - - assert_eq!(parent.hash, expected.hash()); - assert_eq!(&parent.header, expected.header()); - - log::info!( - "Check hash: {:?} expected: {} is: {}", - parent.hash, - is_aligned, - parent.aligned_with_pending, - ); - assert_eq!(parent.aligned_with_pending, is_aligned); - } + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: false, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_aligned: Vec<_> = [&included_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .collect(); + + let expected_parents: Vec<_> = + expected_aligned.clone().into_iter().chain(alt_blocks.iter()).collect(); + + assert_eq!(potential_parents.len(), expected_parents.len()); + for parent in potential_parents.iter() { + let expected = expected_parents + .iter() + .find(|block| block.header().hash() == parent.hash) + .expect("missing parent"); + + let is_aligned = expected_aligned.contains(&expected); + + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + assert_eq!(parent.aligned_with_pending, is_aligned); } } @@ -1771,32 +1648,106 @@ fn find_potential_parents_aligned_no_pending() { parent = block.header().hash(); } - for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { - let potential_parents_aligned = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, // aligned chain is in ancestry. - max_depth, - ignore_alternative_branches: true, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - let potential_parents = block_on(find_potential_parents( - ParentSearchParams { - relay_parent: search_relay_parent, - para_id: ParaId::from(100), - ancestry_lookback: 1, - max_depth, - ignore_alternative_branches: false, - }, - &*backend, - &relay_chain, - )) - .unwrap(); - assert_eq!(potential_parents.len(), 2 * max_depth + 1); - assert_eq!(potential_parents, potential_parents_aligned); + let potential_parents_aligned = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, + ignore_alternative_branches: false, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + // Both chains have NON_INCLUDED_CHAIN_LEN blocks each, plus the included block. + assert_eq!(potential_parents.len(), 2 * NON_INCLUDED_CHAIN_LEN + 1); + assert_eq!(potential_parents, potential_parents_aligned); +} + +#[test] +fn find_potential_parents_no_duplicates() { + sp_tracing::try_init_simple(); + + let backend = Arc::new(Backend::new_test(1000, 1)); + let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); + let mut para_import = + ParachainBlockImport::new_with_delayed_best_block(client.clone(), backend.clone()); + + let relay_parent = relay_hash_from_block_num(10); + // Choose different relay parent for alternative chain to get new hashes. + let search_relay_parent = relay_hash_from_block_num(11); + let included_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + None, + None, + Some(relay_parent), + ); + + let mut blocks = Vec::new(); + + for _ in 0..10 { + blocks.push(build_and_import_block_ext( + &client, + BlockOrigin::Own, + true, + &mut para_import, + Some( + blocks + .last() + .map_or_else(|| included_block.header.hash(), |b: &Block| b.header.hash()), + ), + None, + Some(relay_parent), + )); + } + + let pending_block = blocks.last().unwrap().clone(); + + let relay_chain = Relaychain::new(); + { + let relay_inner = &mut relay_chain.inner.lock().unwrap(); + relay_inner + .relay_chain_hash_to_header + .insert(search_relay_parent, included_block.header().clone()); + relay_inner + .relay_chain_hash_to_header_pending + .insert(search_relay_parent, pending_block.header().clone()); } + + // Ignore alternative branch: + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_parents: Vec<_> = [included_block.header.clone()] + .into_iter() + .chain(blocks.iter().map(|b| b.header.clone())) + .collect(); + + assert_eq!( + potential_parents.into_iter().map(|p| p.header).collect::>(), + expected_parents + ); } diff --git a/prdoc/pr_10973.prdoc b/prdoc/pr_10973.prdoc new file mode 100644 index 0000000000000..9d117d37f72d3 --- /dev/null +++ b/prdoc/pr_10973.prdoc @@ -0,0 +1,12 @@ +title: 'cumulus: Remove `max_depth` for the parent search' +doc: +- audience: Node Dev + description: |- + We were just incrementing this number all the time and there is actually no need to have it, as the search is already automatically bounded. For chains with 500ms blocks and relay offset of 1 we easily go above this limit and this then leads to forks. + + So, let's remove the value. +crates: +- name: cumulus-client-consensus-aura + bump: major +- name: cumulus-client-consensus-common + bump: major