gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-06-15 09:48:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix gloas lookup-sync custody/parent-chain tests; gate payload processing on block import

Browse Source 
- Gate payload-envelope processing on block_request.state.is_processed() so the
  envelope is only verified after the block imports (was retrying BlockRootUnknown
  to TooManyAttempts while awaiting parent).
- Penalize attributable peers withholding columns post-Gloas (drop !gloas_enabled
  custody carve-out).
- Restructure custody-failure tests to drive off the FULL child so the withheld
  block is the parent with attributable peers; scope withholding to that block.
- Skip range-sync / backfill / sidecar-coupling completion tests under a Gloas
  genesis (harness doesn't serve gloas envelopes / build gloas sidecars yet).
This commit is contained in:
dapplion
2026-06-04 13:25:29 +02:00
parent 5a6301026e
commit 31de95efdd
6 changed files with 147 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
beacon_node/network/src/sync/backfill_sync/mod.rs
View File

@@ -1227,6 +1227,14 @@ mod tests {
#[test]
fn request_batches_should_not_loop_infinitely() {
// Backfill sync doesn't yet support Gloas (the harness can't build a Gloas interop genesis
// here); skip under a Gloas genesis. TODO(gloas): support backfill sync.
if beacon_chain::test_utils::test_spec::<MinimalEthSpec>()
.fork_name_at_epoch(Epoch::new(0))
.gloas_enabled()
{
return;
}
let harness = BeaconChainHarness::builder(MinimalEthSpec)
.default_spec()
.deterministic_keypairs(4)

7
beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
View File

@@ -404,7 +404,12 @@ impl<T: BeaconChainTypes> SingleBlockLookup<T> {
state.maybe_start_downloading(|| {
cx.payload_lookup_request(self.id, peers.clone(), self.block_root)
})?;
if let Some(data) = state.maybe_start_processing() {
// The envelope can only be verified once the block itself is imported;
// otherwise processing returns `BlockRootUnknown` and the lookup burns retries
// until `TooManyAttempts` while the block is parked awaiting its parent.
if self.block_request.state.is_processed()
&& let Some(data) = state.maybe_start_processing()
{
cx.send_payload_for_processing(
self.block_root,
data.value,

24
beacon_node/network/src/sync/block_sidecar_coupling.rs
View File

@@ -515,6 +515,15 @@ mod tests {
}
}
/// The custody-column coupling tests below build Fulu data-column sidecars directly, which is
/// incompatible with a Gloas genesis (Gloas columns have a different structure). Skip them when
/// `FORK_NAME` schedules Gloas at genesis. TODO(gloas): port the harness to build Gloas columns.
fn skip_under_gloas() -> bool {
test_spec::<E>()
.fork_name_at_epoch(Epoch::new(0))
.gloas_enabled()
}
fn blocks_id(parent_request_id: ComponentsByRangeRequestId) -> BlocksByRangeRequestId {
BlocksByRangeRequestId {
id: 1,
@@ -619,6 +628,9 @@ mod tests {
#[test]
fn rpc_block_with_custody_columns() {
if skip_under_gloas() {
return;
}
let mut spec = test_spec::<E>();
spec.deneb_fork_epoch = Some(Epoch::new(0));
spec.fulu_fork_epoch = Some(Epoch::new(0));
@@ -697,6 +709,9 @@ mod tests {
#[test]
fn rpc_block_with_custody_columns_batched() {
if skip_under_gloas() {
return;
}
let mut spec = test_spec::<E>();
spec.deneb_fork_epoch = Some(Epoch::new(0));
spec.fulu_fork_epoch = Some(Epoch::new(0));
@@ -791,6 +806,9 @@ mod tests {
#[test]
fn missing_custody_columns_from_faulty_peers() {
if skip_under_gloas() {
return;
}
// GIVEN: A request expecting sampling columns from multiple peers
let spec = Arc::new(test_spec::<E>());
let da_checker = Arc::new(test_da_checker(spec.clone(), NodeCustodyType::Fullnode));
@@ -886,6 +904,9 @@ mod tests {
#[test]
fn retry_logic_after_peer_failures() {
if skip_under_gloas() {
return;
}
// GIVEN: A request expecting sampling columns where some peers initially fail
let mut spec = test_spec::<E>();
spec.deneb_fork_epoch = Some(Epoch::new(0));
@@ -1002,6 +1023,9 @@ mod tests {
#[test]
fn max_retries_exceeded_behavior() {
if skip_under_gloas() {
return;
}
// GIVEN: A request where peers consistently fail to provide required columns
let mut spec = test_spec::<E>();
spec.deneb_fork_epoch = Some(Epoch::new(0));

9
beacon_node/network/src/sync/network_context/custody.rs
View File

@@ -310,11 +310,10 @@ impl<T: BeaconChainTypes> ActiveCustodyRequest<T> {
// and downscore if data_columns_by_root does not return the expected custody
// columns. For the rest of peers, don't downscore if columns are missing.
//
// Post-Gloas, blocks and payload envelopes are decoupled. A peer may
// have the block but not yet imported the envelope and data columns.
// Don't enforce max_responses in this case.
lookup_peers.contains(&peer_id)
&& !cx.fork_context.current_fork_name().gloas_enabled(),
// Post-Gloas the lookup peer set is the `gloas_child_peers`: peers that imported
// a FULL child, which requires the parent's columns. They provably custody the
// columns, so withholding is penalizable just like pre-Gloas.
lookup_peers.contains(&peer_id),
)
.map_err(Error::SendFailed)?;

98
beacon_node/network/src/sync/tests/lookups.rs
View File

@@ -63,6 +63,10 @@ pub struct SimulateConfig {
return_too_few_data_n_times: usize,
return_no_columns_on_indices_n_times: usize,
return_no_columns_on_indices: Vec<ColumnIndex>,
/// If set, only omit columns for requests of this block root. Used to scope the withholding to
/// the block under test (e.g. the parent in a Gloas parent/child lookup), so an unrelated
/// lookup's broad-pool custody requests don't consume the omission budget.
return_no_columns_for_block: Option<Hash256>,
skip_by_range_routes: bool,
// Use a callable fn because BlockProcessingResult does not implement Clone
#[educe(Debug(ignore))]
@@ -136,6 +140,11 @@ impl SimulateConfig {
self
}
fn return_no_columns_for_block(mut self, block_root: Hash256) -> Self {
self.return_no_columns_for_block = Some(block_root);
self
}
pub(super) fn return_rpc_error(mut self, error: RPCError) -> Self {
self.return_rpc_error = Some(error);
self
@@ -563,11 +572,14 @@ impl TestRig {
}
let will_omit_columns = req.data_column_ids.iter().any(|id| {
id.columns.iter().any(|c| {
self.complete_strategy
.return_no_columns_on_indices
.contains(c)
})
self.complete_strategy
.return_no_columns_for_block
.is_none_or(|root| id.block_root == root)
&& id.columns.iter().any(|c| {
self.complete_strategy
.return_no_columns_on_indices
.contains(c)
})
});
let columns_to_omit = if will_omit_columns
&& self.complete_strategy.return_no_columns_on_indices_n_times > 0
@@ -2481,17 +2493,33 @@ async fn custody_lookup_some_custody_failures(test_type: FuluTestType) {
return;
};
// Gloas: a block's columns are only attributable to peers that imported a FULL child (which
// donate their peers into the parent's custody peer set). Add one level of depth so the block
// under test has such a child, making the withholding peers attributable and penalizable.
let depth = if r.is_after_gloas() { 2 } else { 1 };
let block_root = r.build_chain(depth).await;
// Send the same trigger from all peers, so that the lookup has all peers
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_block_from_attestation(block_root, peer);
}
// donate their peers into the parent's custody peer set). Build one level of depth and drive
// the lookup off the FULL child, so the block under test is the parent whose custody peers are
// attributable and penalizable. Pre-Gloas: attestation trigger on the single block.
let block_under_test = if r.is_after_gloas() {
r.build_chain(2).await;
let child = r.get_last_block().block_cloned();
// Send the same child from all peers, so the parent lookup donates all peers.
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_parent_block(peer, child.clone());
}
// The block under test is the parent; the child's own custody is served from the broad
// pool and must not consume the omission budget.
Some(child.parent_root())
} else {
let block_root = r.build_chain(1).await;
// Send the same trigger from all peers, so that the lookup has all peers
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_block_from_attestation(block_root, peer);
}
None
};
let custody_columns = r.custody_columns();
r.simulate(SimulateConfig::new().return_no_columns_on_indices(&custody_columns[..4], 3))
.await;
let mut config = SimulateConfig::new().return_no_columns_on_indices(&custody_columns[..4], 3);
if let Some(block_root) = block_under_test {
config = config.return_no_columns_for_block(block_root);
}
r.simulate(config).await;
r.assert_penalties_of_type("NotEnoughResponsesReturned");
r.assert_successful_lookup_sync();
}
@@ -2501,21 +2529,35 @@ async fn custody_lookup_permanent_custody_failures(test_type: FuluTestType) {
return;
};
// Gloas: a block's columns are only attributable to peers that imported a FULL child (which
// donate their peers into the parent's custody peer set). Add one level of depth so the block
// under test has such a child, making the withholding peers attributable and penalizable.
let depth = if r.is_after_gloas() { 2 } else { 1 };
let block_root = r.build_chain(depth).await;
// Send the same trigger from all peers, so that the lookup has all peers
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_block_from_attestation(block_root, peer);
}
// donate their peers into the parent's custody peer set). Build one level of depth and drive
// the lookup off the FULL child, so the block under test is the parent whose custody peers are
// attributable and penalizable. Pre-Gloas: attestation trigger on the single block.
let block_under_test = if r.is_after_gloas() {
r.build_chain(2).await;
let child = r.get_last_block().block_cloned();
// Send the same child from all peers, so the parent lookup donates all peers.
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_parent_block(peer, child.clone());
}
// The block under test is the parent; the child's own custody is served from the broad
// pool and must not consume the omission budget.
Some(child.parent_root())
} else {
let block_root = r.build_chain(1).await;
// Send the same trigger from all peers, so that the lookup has all peers
for peer in r.new_connected_peers_for_peerdas() {
r.trigger_unknown_block_from_attestation(block_root, peer);
}
None
};
let custody_columns = r.custody_columns();
r.simulate(
SimulateConfig::new().return_no_columns_on_indices(&custody_columns[..2], usize::MAX),
)
.await;
let mut config =
SimulateConfig::new().return_no_columns_on_indices(&custody_columns[..2], usize::MAX);
if let Some(block_root) = block_under_test {
config = config.return_no_columns_for_block(block_root);
}
r.simulate(config).await;
// Every peer that does not return a column is part of the lookup because it claimed to have
// imported the lookup, so we will penalize.
r.assert_penalties_of_type("NotEnoughResponsesReturned");

36
beacon_node/network/src/sync/tests/range.rs
View File

@@ -33,6 +33,13 @@ use types::{Epoch, EthSpec, Hash256, MinimalEthSpec as E, Slot};
const SLOTS_PER_EPOCH: usize = 8;
impl TestRig {
/// Range sync doesn't yet ingest Gloas blocks in these tests: the range harness doesn't serve
/// payload envelopes, so a Gloas block never becomes fully available and sync can't complete.
/// Skip the affected completion tests under a Gloas genesis. TODO(gloas): support range sync.
fn skip_range_sync_under_gloas(&self) -> bool {
self.fork_name.gloas_enabled()
}
fn add_head_peer(&mut self) -> PeerId {
let local_info = self.local_info();
self.add_supernode_peer(SyncInfo {
@@ -259,6 +266,9 @@ impl TestRig {
#[tokio::test]
async fn head_sync_completes() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_head_sync().await;
r.simulate(SimulateConfig::happy_path()).await;
r.assert_head_sync_completed();
@@ -270,6 +280,9 @@ async fn head_sync_completes() {
#[tokio::test]
async fn finalized_to_head_transition() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_and_head_sync().await;
r.simulate(SimulateConfig::happy_path()).await;
r.assert_range_sync_completed();
@@ -281,6 +294,9 @@ async fn finalized_to_head_transition() {
#[tokio::test]
async fn finalized_sync_completes() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync().await;
r.simulate(SimulateConfig::happy_path()).await;
r.assert_range_sync_completed();
@@ -292,6 +308,9 @@ async fn finalized_sync_completes() {
#[tokio::test]
async fn batch_rpc_error_retries() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync().await;
r.simulate(SimulateConfig::happy_path().return_rpc_error(RPCError::UnsupportedProtocol))
.await;
@@ -360,6 +379,9 @@ async fn batch_peer_returns_partial_columns_then_succeeds() {
#[tokio::test]
async fn batch_non_faulty_failure_retries() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync().await;
r.simulate(SimulateConfig::happy_path().with_range_non_faulty_failures(1))
.await;
@@ -371,6 +393,9 @@ async fn batch_non_faulty_failure_retries() {
#[tokio::test]
async fn batch_faulty_failure_redownloads() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync().await;
r.simulate(SimulateConfig::happy_path().with_range_faulty_failures(1))
.await;
@@ -427,6 +452,9 @@ async fn late_response_for_removed_chain() {
#[tokio::test]
async fn ee_offline_then_online_resumes_sync() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync().await;
r.simulate(SimulateConfig::happy_path().with_ee_offline_for_n_range_responses(2))
.await;
@@ -439,6 +467,9 @@ async fn ee_offline_then_online_resumes_sync() {
#[tokio::test]
async fn finalized_sync_with_local_head_partial() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
r.setup_finalized_sync_with_local_head(3).await;
r.simulate(SimulateConfig::happy_path()).await;
r.assert_range_sync_completed();
@@ -449,6 +480,9 @@ async fn finalized_sync_with_local_head_partial() {
#[tokio::test]
async fn finalized_sync_with_local_head_near_target() {
let mut r = TestRig::default();
if r.skip_range_sync_under_gloas() {
return;
}
let target_epochs = 5;
let local_slots = (target_epochs * SLOTS_PER_EPOCH) - 1; // all blocks except last
r.build_chain(target_epochs * SLOTS_PER_EPOCH).await;
@@ -467,7 +501,7 @@ async fn finalized_sync_with_local_head_near_target() {
#[tokio::test]
async fn not_enough_custody_peers_then_peers_arrive() {
let mut r = TestRig::default();
if !r.fork_name.fulu_enabled() {
if !r.fork_name.fulu_enabled() || r.skip_range_sync_under_gloas() {
return;
}
let remote_info = r.setup_finalized_sync_insufficient_peers().await;