Skip to content

Commit 66dbc04

Browse files
eserileveserilev
committed
More lints
1 parent c161333 commit 66dbc04

File tree

4 files changed

+108
-114
lines changed

4 files changed

+108
-114
lines changed

‎beacon_node/beacon_chain/tests/block_verification.rs‎

Lines changed: 11 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -233,7 +233,7 @@ fn update_blob_signed_header<E: EthSpec>(
233233
kzg_commitment_inclusion_proof: signed_block
234234
.message()
235235
.body()
236-
.kzg_commitment_merkle_proof(*old_blob_sidecar.index() as usize)
236+
.kzg_commitment_merkle_proof(old_blob_sidecar.index as usize)
237237
.unwrap(),
238238
});
239239
*old_blob_sidecar = new_blob;
@@ -246,18 +246,18 @@ fn update_data_column_signed_header<E: EthSpec>(
246246
) {
247247
for old_custody_column_sidecar in data_columns.as_mut_slice() {
248248
let old_column_sidecar = old_custody_column_sidecar.as_data_column();
249-
let new_column_sidecar = Arc::new(DataColumnSidecar::<E> {
250-
index: old_column_sidecar.index,
251-
column: old_column_sidecar.column.clone(),
252-
kzg_commitments: old_column_sidecar.kzg_commitments.clone(),
253-
kzg_proofs: old_column_sidecar.kzg_proofs.clone(),
249+
let new_column_sidecar = Arc::new(DataColumnSidecar::Fulu(DataColumnSidecarFulu {
250+
index: *old_column_sidecar.index(),
251+
column: old_column_sidecar.column().clone(),
252+
kzg_commitments: old_column_sidecar.kzg_commitments().clone(),
253+
kzg_proofs: old_column_sidecar.kzg_proofs().clone(),
254254
signed_block_header: signed_block.signed_block_header(),
255255
kzg_commitments_inclusion_proof: signed_block
256256
.message()
257257
.body()
258258
.kzg_commitments_merkle_proof()
259259
.unwrap(),
260-
});
260+
}));
261261
*old_custody_column_sidecar = CustodyDataColumn::from_asserted_custody(new_column_sidecar);
262262
}
263263
}
@@ -1299,20 +1299,8 @@ async fn verify_and_process_gossip_data_sidecars(
12991299
data_sidecars: DataSidecars<E>,
13001300
) {
13011301
match data_sidecars {
1302-
DataSidecars::Blobs(blob_sidecars) => {
1303-
for blob_sidecar in blob_sidecars {
1304-
let blob_index = blob_sidecar.index;
1305-
let gossip_verified = harness
1306-
.chain
1307-
.verify_blob_sidecar_for_gossip(blob_sidecar.clone(), blob_index)
1308-
.expect("should obtain gossip verified blob");
1309-
1310-
harness
1311-
.chain
1312-
.process_gossip_blob(gossip_verified)
1313-
.await
1314-
.expect("should import valid gossip verified blob");
1315-
}
1302+
DataSidecars::Blobs(_blob_sidecars) => {
1303+
panic!("We dont support blobs anymore");
13161304
}
13171305
DataSidecars::DataColumns(column_sidecars) => {
13181306
let gossip_verified = column_sidecars
@@ -1364,12 +1352,9 @@ async fn verify_block_for_gossip_slashing_detection() {
13641352

13651353
let verified_block = harness.chain.verify_block_for_gossip(block1).await.unwrap();
13661354

1367-
if let Some((kzg_proofs, blobs)) = blobs1 {
1355+
if let Some((_, _)) = blobs1 {
13681356
harness
1369-
.process_gossip_columns(
1370-
verified_block.block(),
1371-
Some(get_custody_columns(&tester, block.slot())),
1372-
)
1357+
.process_gossip_columns(verified_block.block(), None)
13731358
.await;
13741359
}
13751360
harness

‎beacon_node/beacon_chain/tests/store_tests.rs‎

Lines changed: 81 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -3380,17 +3380,22 @@ async fn test_import_historical_data_columns_batch() {
33803380
.await;
33813381
harness.advance_slot();
33823382

3383-
let block_root_iter = harness
3383+
let block_root_and_slot = harness
33843384
.chain
33853385
.forwards_iter_block_roots_until(start_slot, end_slot)
33863386
.unwrap();
33873387

33883388
let mut data_columns_list = vec![];
33893389

33903390
// Get all data columns for epoch 0
3391-
for block in block_root_iter {
3392-
let (block_root, _) = block.unwrap();
3393-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3391+
for block_root_and_slot in block_root_and_slot {
3392+
let (block_root, slot) = block_root_and_slot.unwrap();
3393+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3394+
let data_columns = harness
3395+
.chain
3396+
.store
3397+
.get_data_columns(&block_root, fork_name)
3398+
.unwrap();
33943399
for data_column in data_columns.unwrap_or_default() {
33953400
data_columns_list.push(data_column);
33963401
}
@@ -3415,15 +3420,20 @@ async fn test_import_historical_data_columns_batch() {
34153420
.try_prune_blobs(true, Epoch::new(2))
34163421
.unwrap();
34173422

3418-
let block_root_iter = harness
3423+
let block_root_and_slot_iter = harness
34193424
.chain
34203425
.forwards_iter_block_roots_until(start_slot, end_slot)
34213426
.unwrap();
34223427

34233428
// Assert that data columns no longer exist for epoch 0
3424-
for block in block_root_iter {
3425-
let (block_root, _) = block.unwrap();
3426-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3429+
for block_root_and_slot in block_root_and_slot_iter {
3430+
let (block_root, slot) = block_root_and_slot.unwrap();
3431+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3432+
let data_columns = harness
3433+
.chain
3434+
.store
3435+
.get_data_columns(&block_root, fork_name)
3436+
.unwrap();
34273437
assert!(data_columns.is_none())
34283438
}
34293439

@@ -3433,14 +3443,14 @@ async fn test_import_historical_data_columns_batch() {
34333443
.import_historical_data_column_batch(Epoch::new(0), data_columns_list, cgc)
34343444
.unwrap();
34353445

3436-
let block_root_iter = harness
3446+
let block_root_and_slot_iter = harness
34373447
.chain
34383448
.forwards_iter_block_roots_until(start_slot, end_slot)
34393449
.unwrap();
34403450

34413451
// Assert that data columns now exist for epoch 0
3442-
for block in block_root_iter {
3443-
let (block_root, _) = block.unwrap();
3452+
for block_root_and_slot in block_root_and_slot_iter {
3453+
let (block_root, slot) = block_root_and_slot.unwrap();
34443454
if !harness
34453455
.get_block(block_root.into())
34463456
.unwrap()
@@ -3450,7 +3460,12 @@ async fn test_import_historical_data_columns_batch() {
34503460
.unwrap()
34513461
.is_empty()
34523462
{
3453-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3463+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3464+
let data_columns = harness
3465+
.chain
3466+
.store
3467+
.get_data_columns(&block_root, fork_name)
3468+
.unwrap();
34543469
assert!(data_columns.is_some())
34553470
};
34563471
}
@@ -3478,7 +3493,7 @@ async fn test_import_historical_data_columns_batch_mismatched_block_root() {
34783493
.await;
34793494
harness.advance_slot();
34803495

3481-
let block_root_iter = harness
3496+
let block_root_and_slot_iter = harness
34823497
.chain
34833498
.forwards_iter_block_roots_until(start_slot, end_slot)
34843499
.unwrap();
@@ -3487,14 +3502,23 @@ async fn test_import_historical_data_columns_batch_mismatched_block_root() {
34873502

34883503
// Get all data columns from start_slot to end_slot
34893504
// and mutate the data columns with an invalid block root
3490-
for block in block_root_iter {
3491-
let (block_root, _) = block.unwrap();
3492-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3505+
for block_root_and_slot in block_root_and_slot_iter {
3506+
let (block_root, slot) = block_root_and_slot.unwrap();
3507+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3508+
let data_columns = harness
3509+
.chain
3510+
.store
3511+
.get_data_columns(&block_root, fork_name)
3512+
.unwrap();
34933513

34943514
for data_column in data_columns.unwrap_or_default() {
34953515
let mut data_column = (*data_column).clone();
3496-
if data_column.index % 2 == 0 {
3497-
data_column.signed_block_header.message.body_root = Hash256::ZERO;
3516+
if data_column.index() % 2 == 0 {
3517+
data_column
3518+
.signed_block_header_mut()
3519+
.unwrap()
3520+
.message
3521+
.body_root = Hash256::ZERO;
34983522
}
34993523

35003524
data_columns_list.push(Arc::new(data_column));
@@ -3519,15 +3543,20 @@ async fn test_import_historical_data_columns_batch_mismatched_block_root() {
35193543
.try_prune_blobs(true, Epoch::new(2))
35203544
.unwrap();
35213545

3522-
let block_root_iter = harness
3546+
let block_root_and_slot_iter = harness
35233547
.chain
35243548
.forwards_iter_block_roots_until(start_slot, end_slot)
35253549
.unwrap();
35263550

35273551
// Assert there are no columns between start_slot and end_slot
3528-
for block in block_root_iter {
3529-
let (block_root, _) = block.unwrap();
3530-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3552+
for block_root_and_slot in block_root_and_slot_iter {
3553+
let (block_root, slot) = block_root_and_slot.unwrap();
3554+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3555+
let data_columns = harness
3556+
.chain
3557+
.store
3558+
.get_data_columns(&block_root, fork_name)
3559+
.unwrap();
35313560
assert!(data_columns.is_none())
35323561
}
35333562

@@ -3573,20 +3602,29 @@ async fn test_import_historical_data_columns_batch_no_block_found() {
35733602
.await;
35743603
harness.advance_slot();
35753604

3576-
let block_root_iter = harness
3605+
let block_root_and_slot_iter = harness
35773606
.chain
35783607
.forwards_iter_block_roots_until(start_slot, end_slot)
35793608
.unwrap();
35803609

35813610
let mut data_columns_list = vec![];
35823611

3583-
for block in block_root_iter {
3584-
let (block_root, _) = block.unwrap();
3585-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3612+
for block_root_and_slot in block_root_and_slot_iter {
3613+
let (block_root, slot) = block_root_and_slot.unwrap();
3614+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3615+
let data_columns = harness
3616+
.chain
3617+
.store
3618+
.get_data_columns(&block_root, fork_name)
3619+
.unwrap();
35863620

35873621
for data_column in data_columns.unwrap_or_default() {
35883622
let mut data_column = (*data_column).clone();
3589-
data_column.signed_block_header.message.body_root = Hash256::ZERO;
3623+
data_column
3624+
.signed_block_header_mut()
3625+
.unwrap()
3626+
.message
3627+
.body_root = Hash256::ZERO;
35903628
data_columns_list.push(Arc::new(data_column));
35913629
}
35923630
}
@@ -3609,14 +3647,19 @@ async fn test_import_historical_data_columns_batch_no_block_found() {
36093647
.try_prune_blobs(true, Epoch::new(2))
36103648
.unwrap();
36113649

3612-
let block_root_iter = harness
3650+
let block_root_and_slot_iter = harness
36133651
.chain
36143652
.forwards_iter_block_roots_until(start_slot, end_slot)
36153653
.unwrap();
36163654

3617-
for block in block_root_iter {
3618-
let (block_root, _) = block.unwrap();
3619-
let data_columns = harness.chain.store.get_data_columns(&block_root).unwrap();
3655+
for block_root_and_slot in block_root_and_slot_iter {
3656+
let (block_root, slot) = block_root_and_slot.unwrap();
3657+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
3658+
let data_columns = harness
3659+
.chain
3660+
.store
3661+
.get_data_columns(&block_root, fork_name)
3662+
.unwrap();
36203663
assert!(data_columns.is_none())
36213664
}
36223665

@@ -4995,7 +5038,13 @@ fn check_data_column_existence(
49955038
.unwrap()
49965039
.map(Result::unwrap)
49975040
{
4998-
if let Some(columns) = harness.chain.store.get_data_columns(&block_root).unwrap() {
5041+
let fork_name = harness.spec.fork_name_at_slot::<E>(slot);
5042+
if let Some(columns) = harness
5043+
.chain
5044+
.store
5045+
.get_data_columns(&block_root, fork_name)
5046+
.unwrap()
5047+
{
49995048
assert!(should_exist, "columns at slot {slot} exist but should not");
50005049
columns_seen += columns.len();
50015050
} else {

‎beacon_node/http_api/tests/broadcast_validation_tests.rs‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1671,9 +1671,6 @@ pub async fn block_seen_on_gossip_with_columns() {
16711671
blobs.0.len()
16721672
);
16731673

1674-
let partial_kzg_proofs = [*blobs.0.first().unwrap()];
1675-
let partial_blobs = [blobs.1.first().unwrap().clone()];
1676-
16771674
// Simulate the block being seen on gossip.
16781675
block
16791676
.clone()
@@ -1817,7 +1814,7 @@ async fn columns_seen_on_gossip_without_block_and_no_http_columns() {
18171814

18181815
let state_a = tester.harness.get_current_state();
18191816
let ((block, blobs), _) = tester.harness.make_block(state_a, slot_b).await;
1820-
let (kzg_proofs, blobs) = blobs.expect("should have some blobs");
1817+
let (_, blobs) = blobs.expect("should have some blobs");
18211818
assert!(!blobs.is_empty());
18221819

18231820
// Simulate the blobs being seen on gossip.
@@ -1889,9 +1886,8 @@ async fn slashable_columns_seen_on_gossip_cause_failure() {
18891886

18901887
let state_a = tester.harness.get_current_state();
18911888
let ((block_a, blobs_a), _) = tester.harness.make_block(state_a.clone(), slot_b).await;
1892-
let ((block_b, blobs_b), _) = tester.harness.make_block(state_a, slot_b).await;
1889+
let ((block_b, _), _) = tester.harness.make_block(state_a, slot_b).await;
18931890
let (kzg_proofs_a, blobs_a) = blobs_a.expect("should have some blobs");
1894-
let (kzg_proofs_b, blobs_b) = blobs_b.expect("should have some blobs");
18951891

18961892
// Simulate the blobs of block B being seen on gossip.
18971893
tester

0 commit comments

Comments
 (0)