From 9dc19108b4b4b9b6f2261a6c192a0d53acab157c Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 17 Sep 2025 16:46:44 +0200 Subject: [PATCH 01/13] remove option from setup_erasure_shreds_with_index_and_chained_merkle tests helper --- ledger/src/blockstore.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index 714aaed2d3384d..5b4f4fd1b1aa07 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -10155,7 +10155,7 @@ pub mod tests { parent_slot, num_entries, fec_set_index, - Some(Hash::new_from_array(rand::thread_rng().gen())), + Hash::new_from_array(rand::thread_rng().gen()), ) } @@ -10164,14 +10164,14 @@ pub mod tests { parent_slot: u64, num_entries: u64, fec_set_index: u32, - chained_merkle_root: Option, + chained_merkle_root: Hash, ) -> (Vec, Vec, Arc) { setup_erasure_shreds_with_index_and_chained_merkle_and_last_in_slot( slot, parent_slot, num_entries, fec_set_index, - chained_merkle_root, + Some(chained_merkle_root), true, ) } @@ -11142,7 +11142,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let data_shred = data_shreds[0].clone(); let coding_shred = coding_shreds[0].clone(); @@ -11175,7 +11175,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let next_coding_shred = next_coding_shreds[0].clone(); @@ -11214,7 +11214,7 @@ pub mod tests { slot, 10, fec_set_index, - Some(merkle_root), + merkle_root, ); let next_slot_data_shred = next_slot_data_shreds[0].clone(); let next_slot_coding_shred = next_slot_coding_shreds[0].clone(); @@ -11247,7 +11247,7 @@ pub mod tests { slot, 10, fec_set_index, - Some(merkle_root), + merkle_root, ); let next_slot_data_shred = next_slot_data_shreds[0].clone(); @@ -11288,7 +11288,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let data_shred = data_shreds[0].clone(); let coding_shred = coding_shreds[0].clone(); @@ -11336,7 +11336,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let data_shred = data_shreds[0].clone(); let coding_shred = coding_shreds[0].clone(); @@ -11380,7 +11380,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let next_data_shred = next_data_shreds[0].clone(); @@ -11427,7 +11427,7 @@ pub mod tests { parent_slot, 10, fec_set_index, - Some(merkle_root), + merkle_root, ); let data_shred = data_shreds[0].clone(); let coding_shred = coding_shreds[0].clone(); @@ -11442,7 +11442,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let next_data_shred = next_data_shreds[0].clone(); @@ -11532,7 +11532,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let data_shred = data_shreds[0].clone(); let coding_shred = coding_shreds[0].clone(); @@ -11567,7 +11567,7 @@ pub mod tests { parent_slot, 10, next_fec_set_index, - Some(merkle_root), + merkle_root, ); let next_data_shred = next_data_shreds[0].clone(); From f914653ebd5677a67bc4aacab479b63b4a8a4bf2 Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 17 Sep 2025 16:50:46 +0200 Subject: [PATCH 02/13] switch to chained merkle root in test_invalid_forks_persisted_on_restart --- local-cluster/tests/local_cluster.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/local-cluster/tests/local_cluster.rs b/local-cluster/tests/local_cluster.rs index e802da3ae60648..a847eddfeef4c3 100644 --- a/local-cluster/tests/local_cluster.rs +++ b/local-cluster/tests/local_cluster.rs @@ -5890,10 +5890,10 @@ fn test_invalid_forks_persisted_on_restart() { .entries_to_merkle_shreds_for_tests( &majority_keypair, &entries, - true, // is_full_slot - None, // chained_merkle_root - 0, // next_shred_index, - 0, // next_code_index + true, // is_full_slot + Some(Hash::default()), // chained_merkle_root + 0, // next_shred_index, + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ) From accf757a23d95683955731bfb3cc42e8e95943f8 Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 17 Sep 2025 19:49:13 +0200 Subject: [PATCH 03/13] remove unchained variants from test_shred_variant_compat_merkle_data --- ledger/src/shred.rs | 48 ++++++++++++++++++++++++++------------------- 1 file changed, 28 insertions(+), 20 deletions(-) diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index 6c3d8fd3de654d..fc16bb6ecbf884 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -64,9 +64,7 @@ pub use { }; use { self::{shred_code::ShredCode, traits::Shred as _}, - crate::{ - blockstore::{self}, - }, + crate::blockstore::{self}, assert_matches::debug_assert_matches, bitflags::bitflags, num_enum::{IntoPrimitive, TryFromPrimitive}, @@ -1002,13 +1000,14 @@ mod tests { const SIZE_OF_SHRED_INDEX: usize = 4; const SIZE_OF_SHRED_SLOT: usize = 8; const SIZE_OF_SHRED_VARIANT: usize = 1; - const SIZE_OF_VERSION : usize = 2; + const SIZE_OF_VERSION: usize = 2; const SIZE_OF_FEC_SET_INDEX: usize = 4; const OFFSET_OF_SHRED_VARIANT: usize = SIZE_OF_SIGNATURE; const OFFSET_OF_SHRED_SLOT: usize = SIZE_OF_SIGNATURE + SIZE_OF_SHRED_VARIANT; const OFFSET_OF_SHRED_INDEX: usize = OFFSET_OF_SHRED_SLOT + SIZE_OF_SHRED_SLOT; - const OFFSET_OF_FEC_SET_INDEX: usize = OFFSET_OF_SHRED_INDEX + SIZE_OF_SHRED_INDEX + SIZE_OF_VERSION; + const OFFSET_OF_FEC_SET_INDEX: usize = + OFFSET_OF_SHRED_INDEX + SIZE_OF_SHRED_INDEX + SIZE_OF_VERSION; const OFFSET_OF_NUM_DATA: usize = OFFSET_OF_FEC_SET_INDEX + SIZE_OF_FEC_SET_INDEX; pub(super) fn make_merkle_shreds_for_tests( @@ -1440,7 +1439,9 @@ mod tests { let bad_fec_set_index = 5u32; { let mut cursor = Cursor::new(packet.buffer_mut()); - cursor.seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)).unwrap(); + cursor + .seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)) + .unwrap(); cursor.write_all(&bad_fec_set_index.to_le_bytes()).unwrap(); } @@ -1470,7 +1471,9 @@ mod tests { .seek(SeekFrom::Start(OFFSET_OF_SHRED_INDEX as u64)) .unwrap(); cursor.write_all(&bad_index.to_le_bytes()).unwrap(); - cursor.seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)).unwrap(); + cursor + .seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)) + .unwrap(); cursor.write_all(&fec_set_index.to_le_bytes()).unwrap(); } @@ -1499,7 +1502,9 @@ mod tests { let bad_num_data = 16u16; { let mut cursor = Cursor::new(packet.buffer_mut()); - cursor.seek(SeekFrom::Start(OFFSET_OF_NUM_DATA as u64)).unwrap(); + cursor + .seek(SeekFrom::Start(OFFSET_OF_NUM_DATA as u64)) + .unwrap(); cursor.write_all(&bad_num_data.to_le_bytes()).unwrap(); } @@ -1522,7 +1527,7 @@ mod tests { slot, 1200 * 5, // data_size true, // chained - true, // is_last_in_slot + true, // is_last_in_slot ) .unwrap(); let shreds: Vec<_> = shreds.into_iter().map(Shred::from).collect(); @@ -1542,9 +1547,13 @@ mod tests { let fec_set_index = 0u32; { let mut cursor = Cursor::new(packet.buffer_mut()); - cursor.seek(SeekFrom::Start(OFFSET_OF_SHRED_INDEX as u64)).unwrap(); + cursor + .seek(SeekFrom::Start(OFFSET_OF_SHRED_INDEX as u64)) + .unwrap(); cursor.write_all(&bad_last_index.to_le_bytes()).unwrap(); - cursor.seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)).unwrap(); + cursor + .seek(SeekFrom::Start(OFFSET_OF_FEC_SET_INDEX as u64)) + .unwrap(); cursor.write_all(&fec_set_index.to_le_bytes()).unwrap(); } @@ -1653,16 +1662,15 @@ mod tests { } } - #[test_case(false, false, 0b1000_0000)] - #[test_case(true, false, 0b1001_0000)] - #[test_case(true, true, 0b1011_0000)] - fn test_shred_variant_compat_merkle_data(chained: bool, resigned: bool, byte: u8) { + #[test_case(false, 0b1001_0000)] + #[test_case(true, 0b1011_0000)] + fn test_shred_variant_compat_merkle_data(resigned: bool, byte: u8) { for proof_size in 0..=15u8 { let byte = byte | proof_size; assert_eq!( u8::from(ShredVariant::MerkleData { proof_size, - chained, + chained: true, resigned, }), byte @@ -1670,7 +1678,7 @@ mod tests { assert_eq!( ShredType::from(ShredVariant::MerkleData { proof_size, - chained, + chained: true, resigned, }), ShredType::Data @@ -1679,13 +1687,13 @@ mod tests { ShredVariant::try_from(byte).unwrap(), ShredVariant::MerkleData { proof_size, - chained, + chained: true, resigned } ); let buf = bincode::serialize(&ShredVariant::MerkleData { proof_size, - chained, + chained: true, resigned, }) .unwrap(); @@ -1694,7 +1702,7 @@ mod tests { bincode::deserialize::(&[byte]).unwrap(), ShredVariant::MerkleData { proof_size, - chained, + chained: true, resigned } ); From 46b74b1cb9e56df42ee1eb8ebc397f1b9d605f7e Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 17 Sep 2025 19:54:47 +0200 Subject: [PATCH 04/13] remove unchained variant from test_shred_variant_compat_merkle_code --- ledger/src/shred.rs | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index fc16bb6ecbf884..b46740fc25c929 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -1614,16 +1614,15 @@ mod tests { assert_matches!(bincode::deserialize::(&[0b1010_0101]), Err(_)); } - #[test_case(false, false, 0b0100_0000)] - #[test_case(true, false, 0b0110_0000)] - #[test_case(true, true, 0b0111_0000)] - fn test_shred_variant_compat_merkle_code(chained: bool, resigned: bool, byte: u8) { + #[test_case(false, 0b0110_0000)] + #[test_case(true, 0b0111_0000)] + fn test_shred_variant_compat_merkle_code(resigned: bool, byte: u8) { for proof_size in 0..=15u8 { let byte = byte | proof_size; assert_eq!( u8::from(ShredVariant::MerkleCode { proof_size, - chained, + chained: true, resigned, }), byte @@ -1631,7 +1630,7 @@ mod tests { assert_eq!( ShredType::from(ShredVariant::MerkleCode { proof_size, - chained, + chained: true, resigned, }), ShredType::Code @@ -1640,13 +1639,13 @@ mod tests { ShredVariant::try_from(byte).unwrap(), ShredVariant::MerkleCode { proof_size, - chained, + chained: true, resigned, }, ); let buf = bincode::serialize(&ShredVariant::MerkleCode { proof_size, - chained, + chained: true, resigned, }) .unwrap(); @@ -1655,7 +1654,7 @@ mod tests { bincode::deserialize::(&[byte]).unwrap(), ShredVariant::MerkleCode { proof_size, - chained, + chained: true, resigned, } ); From 4bf832edb23ce73367ad6672cb81cc3f8e43872f Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 17 Sep 2025 20:09:11 +0200 Subject: [PATCH 05/13] remove unchained variant from test_is_shred_duplicate --- ledger/src/shred.rs | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index b46740fc25c929..ceb65a30047928 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -994,7 +994,7 @@ mod tests { rayon::ThreadPoolBuilder, solana_keypair::keypair_from_seed, std::io::{Cursor, Seek, SeekFrom, Write}, - test_case::{test_case, test_matrix}, + test_case::test_case, }; const SIZE_OF_SHRED_INDEX: usize = 4; @@ -1937,15 +1937,12 @@ mod tests { assert!(flags.contains(ShredFlags::LAST_SHRED_IN_SLOT)); } - #[test_matrix( - [true, false], - [true, false] - )] - fn test_is_shred_duplicate(chained: bool, is_last_in_slot: bool) { + #[test_case(true)] + #[test_case(false)] + fn test_is_shred_duplicate(is_last_in_slot: bool) { fn fill_retransmitter_signature( rng: &mut R, shred: Shred, - chained: bool, is_last_in_slot: bool, ) -> Shred { let mut shred = shred.into_payload(); @@ -1955,26 +1952,27 @@ mod tests { &mut shred.as_mut(), &Signature::from(signature), ); - if chained && is_last_in_slot { + if is_last_in_slot { assert_matches!(out, Ok(())); } else { assert_matches!(out, Err(Error::InvalidShredVariant)); } Shred::new_from_serialized_shred(shred).unwrap() } + let mut rng = rand::thread_rng(); let slot = 285_376_049 + rng.gen_range(0..100_000); let shreds: Vec<_> = make_merkle_shreds_for_tests( &mut rng, slot, 1200 * 5, // data_size - chained, + true, is_last_in_slot, ) .unwrap() .into_iter() .map(Shred::from) - .map(|shred| fill_retransmitter_signature(&mut rng, shred, chained, is_last_in_slot)) + .map(|shred| fill_retransmitter_signature(&mut rng, shred, is_last_in_slot)) .collect(); { let num_data_shreds = shreds.iter().filter(|shred| shred.is_data()).count(); @@ -1991,9 +1989,8 @@ mod tests { } // Different retransmitter signature does not make shreds duplicate. for shred in &shreds { - let other = - fill_retransmitter_signature(&mut rng, shred.clone(), chained, is_last_in_slot); - if chained && is_last_in_slot { + let other = fill_retransmitter_signature(&mut rng, shred.clone(), is_last_in_slot); + if is_last_in_slot { assert_ne!(shred.payload(), other.payload()); } assert!(!shred.is_shred_duplicate(&other)); From 7c333c5e34ea274183cc8a1a46a5d55a0a020190 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 08:14:52 +0200 Subject: [PATCH 06/13] remove last part of the test_check_last_fec_set aka slot is full, but does not contain retransmitter shreds --- ledger/src/blockstore.rs | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index 5b4f4fd1b1aa07..02a24f306468b6 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -11734,28 +11734,6 @@ pub mod tests { let results = blockstore.check_last_fec_set(slot).unwrap(); assert_eq!(results.last_fec_set_merkle_root, Some(merkle_root)); assert!(!results.is_retransmitter_signed); - blockstore.run_purge(slot, slot, PurgeType::Exact).unwrap(); - - // Slot is full, but does not contain retransmitter shreds - let fec_set_index = 0; - let (first_data_shreds, _, _) = - setup_erasure_shreds_with_index_and_chained_merkle_and_last_in_slot( - slot, - parent_slot, - 200, - fec_set_index, - // Do not set merkle root, so shreds are not signed - None, - true, - ); - assert!(first_data_shreds.len() > DATA_SHREDS_PER_FEC_BLOCK); - let block_id = first_data_shreds.last().unwrap().merkle_root().unwrap(); - blockstore - .insert_shreds(first_data_shreds, None, false) - .unwrap(); - let results = blockstore.check_last_fec_set(slot).unwrap(); - assert_eq!(results.last_fec_set_merkle_root, Some(block_id)); - assert!(!results.is_retransmitter_signed); } #[test] From 4042636db50b6ff990273387b112545e76a3f1b5 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 08:30:30 +0200 Subject: [PATCH 07/13] remove option from chained_merkle_root param in setup_erasure_shreds_with_index_and_chained_merkle_and_last_in_slot --- ledger/src/blockstore.rs | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index 02a24f306468b6..1fb7fc7d265d02 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -7618,7 +7618,12 @@ pub mod tests { let slot = 1; let (_data_shreds, code_shreds, _) = setup_erasure_shreds_with_index_and_chained_merkle_and_last_in_slot( - slot, 0, 10, 0, None, true, + slot, + 0, + 10, + 0, + Hash::default(), + true, ); let coding_shred = code_shreds[0].clone(); @@ -7655,7 +7660,12 @@ pub mod tests { let slot = 1; let (_data_shreds, code_shreds, _) = setup_erasure_shreds_with_index_and_chained_merkle_and_last_in_slot( - slot, 0, 10, 0, None, true, + slot, + 0, + 10, + 0, + Hash::default(), + true, ); let coding_shred = code_shreds[0].clone(); @@ -10171,7 +10181,7 @@ pub mod tests { parent_slot, num_entries, fec_set_index, - Some(chained_merkle_root), + chained_merkle_root, true, ) } @@ -10181,7 +10191,7 @@ pub mod tests { parent_slot: u64, num_entries: u64, fec_set_index: u32, - chained_merkle_root: Option, + chained_merkle_root: Hash, is_last_in_slot: bool, ) -> (Vec, Vec, Arc) { let entries = make_slot_entries_with_transactions(num_entries); @@ -10191,7 +10201,7 @@ pub mod tests { &leader_keypair, &entries, is_last_in_slot, - chained_merkle_root, + Some(chained_merkle_root), fec_set_index, // next_shred_index fec_set_index, // next_code_index &ReedSolomonCache::default(), @@ -11661,7 +11671,7 @@ pub mod tests { parent_slot, 10, fec_set_index, - None, + Hash::default(), false, ); let merkle_root = first_data_shreds[0].merkle_root().unwrap(); @@ -11672,7 +11682,7 @@ pub mod tests { parent_slot, 40, fec_set_index, - Some(merkle_root), + merkle_root, false, ); let last_index = last_data_shreds.last().unwrap().index(); @@ -11702,7 +11712,7 @@ pub mod tests { parent_slot, 100, fec_set_index, - None, + Hash::default(), false, ); let merkle_root = first_data_shreds[0].merkle_root().unwrap(); @@ -11713,7 +11723,7 @@ pub mod tests { parent_slot, 100, fec_set_index, - Some(merkle_root), + merkle_root, false, ); let last_index = last_data_shreds.last().unwrap().index(); From 9daba0e66c2ef852f0502f0fef6de5696880b68f Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 08:43:54 +0200 Subject: [PATCH 08/13] remove option from chained_merkle_root param in ledger/benches/make_shreds_from_entries --- ledger/benches/make_shreds_from_entries.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ledger/benches/make_shreds_from_entries.rs b/ledger/benches/make_shreds_from_entries.rs index d0571b167eab74..4db8be5da265ee 100644 --- a/ledger/benches/make_shreds_from_entries.rs +++ b/ledger/benches/make_shreds_from_entries.rs @@ -53,7 +53,7 @@ fn make_shreds_from_entries( keypair: &Keypair, entries: &[Entry], is_last_in_slot: bool, - chained_merkle_root: Option, + chained_merkle_root: Hash, reed_solomon_cache: &ReedSolomonCache, stats: &mut ProcessShredsStats, ) -> (Vec, Vec) { @@ -61,7 +61,7 @@ fn make_shreds_from_entries( keypair, entries, is_last_in_slot, - chained_merkle_root, + Some(chained_merkle_root), rng.gen_range(0..2_000), // next_shred_index rng.gen_range(0..2_000), // next_code_index reed_solomon_cache, @@ -89,7 +89,7 @@ fn run_make_shreds_from_entries( let keypair = Keypair::new(); let data_size = num_packets * PACKET_DATA_SIZE; let entries = make_dummy_entries(&mut rng, data_size); - let chained_merkle_root = Some(make_dummy_hash(&mut rng)); + let chained_merkle_root = make_dummy_hash(&mut rng); let reed_solomon_cache = ReedSolomonCache::default(); let mut stats = ProcessShredsStats::default(); // Initialize the thread-pool and warm the Reed-Solomon cache. @@ -143,7 +143,7 @@ fn run_recover_shreds( let keypair = Keypair::new(); let data_size = num_packets * PACKET_DATA_SIZE; let entries = make_dummy_entries(&mut rng, data_size); - let chained_merkle_root = Some(make_dummy_hash(&mut rng)); + let chained_merkle_root = make_dummy_hash(&mut rng); let reed_solomon_cache = ReedSolomonCache::default(); let mut stats = ProcessShredsStats::default(); let (data, code) = make_shreds_from_entries( From 581738387f64564596b8cc8ca9ee7db58aba37f1 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 09:52:14 +0200 Subject: [PATCH 09/13] remove option from chained_merkle_root param in shredder/entries_to_merkle_shreds_for_tests --- core/benches/shredder.rs | 18 +++---- core/src/repair/repair_weighted_traversal.rs | 2 +- core/src/repair/serve_repair.rs | 4 +- core/src/window_service.rs | 2 +- gossip/src/duplicate_shred.rs | 2 +- ledger/benches/make_shreds_from_entries.rs | 2 +- ledger/src/blockstore.rs | 28 +++++------ ledger/src/shredder.rs | 48 +++++++++---------- ledger/src/sigverify_shreds.rs | 4 +- ledger/tests/shred.rs | 9 ++-- local-cluster/tests/local_cluster.rs | 8 ++-- turbine/src/broadcast_stage.rs | 2 +- .../broadcast_duplicates_run.rs | 6 +-- .../broadcast_fake_shreds_run.rs | 4 +- .../fail_entry_verification_broadcast_run.rs | 6 +-- turbine/src/retransmit_stage.rs | 2 +- turbine/src/sigverify_shreds.rs | 4 +- 17 files changed, 75 insertions(+), 76 deletions(-) diff --git a/core/benches/shredder.rs b/core/benches/shredder.rs index 553e2b86cd0833..cecaba7f214830 100644 --- a/core/benches/shredder.rs +++ b/core/benches/shredder.rs @@ -43,7 +43,7 @@ fn bench_shredder_ticks(bencher: &mut Bencher) { let num_ticks = max_ticks_per_n_shreds(1, Some(SHRED_SIZE_TYPICAL)) * num_shreds as u64; let entries = create_ticks(num_ticks, 0, Hash::default()); let reed_solomon_cache = ReedSolomonCache::default(); - let chained_merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let chained_merkle_root = Hash::new_from_array(rand::thread_rng().gen()); bencher.iter(|| { let shredder = Shredder::new(1, 0, 0, 0).unwrap(); shredder.entries_to_merkle_shreds_for_tests( @@ -71,7 +71,7 @@ fn bench_shredder_large_entries(bencher: &mut Bencher) { Some(shred_size), ); let entries = make_large_unchained_entries(txs_per_entry, num_entries); - let chained_merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let chained_merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let reed_solomon_cache = ReedSolomonCache::default(); // 1Mb bencher.iter(|| { @@ -98,7 +98,7 @@ fn bench_deshredder(bencher: &mut Bencher) { let num_ticks = max_ticks_per_n_shreds(1, Some(shred_size)) * num_shreds as u64; let entries = create_ticks(num_ticks, 0, Hash::default()); let shredder = Shredder::new(1, 0, 0, 0).unwrap(); - let chained_merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let chained_merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let (data_shreds, _) = shredder.entries_to_merkle_shreds_for_tests( &kp, &entries, @@ -120,7 +120,7 @@ fn bench_deshredder(bencher: &mut Bencher) { fn bench_deserialize_hdr(bencher: &mut Bencher) { let keypair = Keypair::new(); let shredder = Shredder::new(2, 1, 0, 0).unwrap(); - let merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let mut stats = ProcessShredsStats::default(); let reed_solomon_cache = ReedSolomonCache::default(); let mut shreds = shredder @@ -128,7 +128,7 @@ fn bench_deserialize_hdr(bencher: &mut Bencher) { &keypair, &[], true, // is_last_in_slot - merkle_root, + Some(merkle_root), 1, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -155,14 +155,14 @@ fn bench_shredder_coding(bencher: &mut Bencher) { let entries = make_entries(); let shredder = Shredder::new(1, 0, 0, 0).unwrap(); let reed_solomon_cache = ReedSolomonCache::default(); - let merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let merkle_root = Hash::new_from_array(rand::thread_rng().gen()); bencher.iter(|| { let result: Vec<_> = shredder .make_merkle_shreds_from_entries( &Keypair::new(), &entries, true, // is_last_in_slot - merkle_root, + Some(merkle_root), 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -178,13 +178,13 @@ fn bench_shredder_decoding(bencher: &mut Bencher) { let entries = make_entries(); let shredder = Shredder::new(1, 0, 0, 0).unwrap(); let reed_solomon_cache = ReedSolomonCache::default(); - let merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let (_data_shreds, mut coding_shreds): (Vec<_>, Vec<_>) = shredder .make_merkle_shreds_from_entries( &Keypair::new(), &entries, true, // is_last_in_slot - merkle_root, + Some(merkle_root), 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, diff --git a/core/src/repair/repair_weighted_traversal.rs b/core/src/repair/repair_weighted_traversal.rs index 97100d4e479ba1..6ffc02071a5b1b 100644 --- a/core/src/repair/repair_weighted_traversal.rs +++ b/core/src/repair/repair_weighted_traversal.rs @@ -293,7 +293,7 @@ pub mod test { &keypair, &[], true, - Some(Hash::default()), + Hash::default(), last_shred as u32, last_shred as u32, &reed_solomon_cache, diff --git a/core/src/repair/serve_repair.rs b/core/src/repair/serve_repair.rs index a2432bd72eda7f..4df23b60a43650 100644 --- a/core/src/repair/serve_repair.rs +++ b/core/src/repair/serve_repair.rs @@ -1838,7 +1838,7 @@ mod tests { &keypair, &[], true, - Some(Hash::default()), + Hash::default(), index as u32, index as u32, &reed_solomon_cache, @@ -2277,7 +2277,7 @@ mod tests { &keypair, &[], true, - Some(Hash::default()), + Hash::default(), 0, 0, &reed_solomon_cache, diff --git a/core/src/window_service.rs b/core/src/window_service.rs index f796ec5cb55ed4..973de3cabb46a4 100644 --- a/core/src/window_service.rs +++ b/core/src/window_service.rs @@ -486,7 +486,7 @@ mod test { entries, true, // is_last_in_slot // chained_merkle_root - Some(Hash::new_from_array(rand::thread_rng().gen())), + Hash::new_from_array(rand::thread_rng().gen()), 0, // next_shred_index 0, // next_code_index &ReedSolomonCache::default(), diff --git a/gossip/src/duplicate_shred.rs b/gossip/src/duplicate_shred.rs index 9dfb753ca2a49f..fbbe69b20ae278 100644 --- a/gossip/src/duplicate_shred.rs +++ b/gossip/src/duplicate_shred.rs @@ -457,7 +457,7 @@ pub(crate) mod tests { &entries, is_last_in_slot, // chained_merkle_root - Some(Hash::new_from_array(rng.gen())), + Hash::new_from_array(rng.gen()), next_shred_index, next_code_index, // next_code_index &ReedSolomonCache::default(), diff --git a/ledger/benches/make_shreds_from_entries.rs b/ledger/benches/make_shreds_from_entries.rs index 4db8be5da265ee..dcfef025c5636f 100644 --- a/ledger/benches/make_shreds_from_entries.rs +++ b/ledger/benches/make_shreds_from_entries.rs @@ -61,7 +61,7 @@ fn make_shreds_from_entries( keypair, entries, is_last_in_slot, - Some(chained_merkle_root), + chained_merkle_root, rng.gen_range(0..2_000), // next_shred_index rng.gen_range(0..2_000), // next_code_index reed_solomon_cache, diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index 1fb7fc7d265d02..e2c9e77f3a32f4 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -2375,7 +2375,7 @@ impl Blockstore { let mut all_shreds = vec![]; let mut slot_entries = vec![]; let reed_solomon_cache = ReedSolomonCache::default(); - let mut chained_merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let mut chained_merkle_root = Hash::new_from_array(rand::thread_rng().gen()); // Find all the entries for start_slot for entry in entries.into_iter() { if remaining_ticks_in_slot == 0 { @@ -2403,7 +2403,7 @@ impl Blockstore { ); all_shreds.append(&mut data_shreds); all_shreds.append(&mut coding_shreds); - chained_merkle_root = Some(coding_shreds.last().unwrap().merkle_root().unwrap()); + chained_merkle_root = coding_shreds.last().unwrap().merkle_root().unwrap(); shredder = Shredder::new( current_slot, parent_slot, @@ -2424,7 +2424,7 @@ impl Blockstore { keypair, &slot_entries, is_full_slot, - chained_merkle_root, + Some(chained_merkle_root), 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -4862,7 +4862,7 @@ pub fn create_new_ledger( &entries, true, // is_last_in_slot // chained_merkle_root - Some(Hash::new_from_array(rand::thread_rng().gen())), + Hash::new_from_array(rand::thread_rng().gen()), 0, // next_shred_index 0, // next_code_index &ReedSolomonCache::default(), @@ -7060,7 +7060,7 @@ pub mod tests { &keypair, &entries, true, - Some(Hash::default()), // merkle_root + Hash::default(), // merkle_root 0, 0, &rsc, @@ -7088,9 +7088,9 @@ pub mod tests { &keypair, &[], true, - Some(Hash::default()), // merkle_root - 6, // next_shred_index, - 6, // next_code_index + Hash::default(), // merkle_root + 6, // next_shred_index, + 6, // next_code_index &rsc, &mut ProcessShredsStats::default(), ) @@ -7151,9 +7151,9 @@ pub mod tests { &Keypair::new(), &entries, true, - Some(Hash::default()), // merkle_root - last_idx, // next_shred_index, - last_idx, // next_code_index + Hash::default(), // merkle_root + last_idx, // next_shred_index, + last_idx, // next_code_index &rsc, &mut ProcessShredsStats::default(), ) @@ -10201,7 +10201,7 @@ pub mod tests { &leader_keypair, &entries, is_last_in_slot, - Some(chained_merkle_root), + chained_merkle_root, fec_set_index, // next_shred_index fec_set_index, // next_code_index &ReedSolomonCache::default(), @@ -10261,7 +10261,7 @@ pub mod tests { let leader_keypair = Arc::new(Keypair::new()); let reed_solomon_cache = ReedSolomonCache::default(); let shredder = Shredder::new(slot, 0, 0, 0).unwrap(); - let merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let (shreds, _) = shredder.entries_to_merkle_shreds_for_tests( &leader_keypair, &entries1, @@ -10621,7 +10621,7 @@ pub mod tests { let version = version_from_hash(&entries[0].hash); let shredder = Shredder::new(slot, 0, 0, version).unwrap(); let reed_solomon_cache = ReedSolomonCache::default(); - let merkle_root = Some(Hash::new_from_array(rand::thread_rng().gen())); + let merkle_root = Hash::new_from_array(rand::thread_rng().gen()); let kp = Keypair::new(); // produce normal shreds let (data1, coding1) = shredder.entries_to_merkle_shreds_for_tests( diff --git a/ledger/src/shredder.rs b/ledger/src/shredder.rs index 036a5127c7c0c2..3d1f3b2581133b 100644 --- a/ledger/src/shredder.rs +++ b/ledger/src/shredder.rs @@ -128,7 +128,7 @@ impl Shredder { keypair: &Keypair, entries: &[Entry], is_last_in_slot: bool, - chained_merkle_root: Option, + chained_merkle_root: Hash, next_shred_index: u32, next_code_index: u32, reed_solomon_cache: &ReedSolomonCache, @@ -141,7 +141,7 @@ impl Shredder { keypair, entries, is_last_in_slot, - chained_merkle_root, + Some(chained_merkle_root), next_shred_index, next_code_index, reed_solomon_cache, @@ -204,7 +204,7 @@ impl Shredder { keypair, &[], true, - Some(Hash::default()), + Hash::default(), 0, 0, &reed_solomon_cache, @@ -308,9 +308,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - start_index, // next_shred_index - start_index, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + start_index, // next_shred_index + start_index, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -394,9 +394,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - 369, // next_shred_index - 776, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 369, // next_shred_index + 776, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -426,9 +426,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -463,9 +463,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -510,9 +510,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -560,9 +560,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); @@ -594,9 +594,9 @@ mod tests { &keypair, &entries, is_last_in_slot, - Some(Hash::new_from_array(rand::thread_rng().gen())), // chained_merkle_root - start_index, // next_shred_index - start_index, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + start_index, // next_shred_index + start_index, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); diff --git a/ledger/src/sigverify_shreds.rs b/ledger/src/sigverify_shreds.rs index 39690dc37b6ff8..78d138b24c1316 100644 --- a/ledger/src/sigverify_shreds.rs +++ b/ledger/src/sigverify_shreds.rs @@ -556,7 +556,7 @@ mod tests { &keypair, &[], true, - Some(Hash::default()), + Hash::default(), 0, 0, &reed_solomon_cache, @@ -689,7 +689,7 @@ mod tests { keypair, &[], true, - Some(Hash::default()), + Hash::default(), 0, 0, &reed_solomon_cache, diff --git a/ledger/tests/shred.rs b/ledger/tests/shred.rs index 10abd780e0e57c..a4c2b36cb0380e 100644 --- a/ledger/tests/shred.rs +++ b/ledger/tests/shred.rs @@ -33,7 +33,6 @@ fn test_multi_fec_block_coding(is_last_in_slot: bool) { let keypair1 = Keypair::new(); let tx0 = system_transaction::transfer(&keypair0, &keypair1.pubkey(), 1, Hash::default()); let entry = Entry::new(&Hash::default(), 1, vec![tx0]); - let chained_merkle_root = Some(Hash::default()); let num_entries = max_entries_per_n_shred_last_or_not(&entry, num_data_shreds as u64, is_last_in_slot); @@ -54,9 +53,9 @@ fn test_multi_fec_block_coding(is_last_in_slot: bool) { &keypair, &entries, is_last_in_slot, - chained_merkle_root, - 0, // next_shred_index - 0, // next_code_index + Hash::default(), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &reed_solomon_cache, &mut ProcessShredsStats::default(), ); @@ -202,7 +201,7 @@ fn setup_different_sized_fec_blocks( let tx0 = system_transaction::transfer(&keypair0, &keypair1.pubkey(), 1, Hash::default()); let entry = Entry::new(&Hash::default(), 1, vec![tx0]); let merkle_capacity = ShredData::capacity(Some((6, true, true))).unwrap(); - let chained_merkle_root = Some(Hash::default()); + let chained_merkle_root = Hash::default(); assert!(DATA_SHREDS_PER_FEC_BLOCK > 2); let num_shreds_per_iter = DATA_SHREDS_PER_FEC_BLOCK; diff --git a/local-cluster/tests/local_cluster.rs b/local-cluster/tests/local_cluster.rs index a847eddfeef4c3..b94d1a1ebc1cd3 100644 --- a/local-cluster/tests/local_cluster.rs +++ b/local-cluster/tests/local_cluster.rs @@ -5890,10 +5890,10 @@ fn test_invalid_forks_persisted_on_restart() { .entries_to_merkle_shreds_for_tests( &majority_keypair, &entries, - true, // is_full_slot - Some(Hash::default()), // chained_merkle_root - 0, // next_shred_index, - 0, // next_code_index + true, // is_full_slot + Hash::default(), // chained_merkle_root + 0, // next_shred_index, + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ) diff --git a/turbine/src/broadcast_stage.rs b/turbine/src/broadcast_stage.rs index 739ef3641c5553..48567c69830b17 100644 --- a/turbine/src/broadcast_stage.rs +++ b/turbine/src/broadcast_stage.rs @@ -624,7 +624,7 @@ pub mod test { &entries, true, // is_last_in_slot // chained_merkle_root - Some(Hash::new_from_array(rand::thread_rng().gen())), + Hash::new_from_array(rand::thread_rng().gen()), 0, // next_shred_index, 0, // next_code_index &ReedSolomonCache::default(), diff --git a/turbine/src/broadcast_stage/broadcast_duplicates_run.rs b/turbine/src/broadcast_stage/broadcast_duplicates_run.rs index 664123e203c045..6d9592502eed56 100644 --- a/turbine/src/broadcast_stage/broadcast_duplicates_run.rs +++ b/turbine/src/broadcast_stage/broadcast_duplicates_run.rs @@ -185,7 +185,7 @@ impl BroadcastRun for BroadcastDuplicatesRun { keypair, &receive_results.entries, last_tick_height == bank.max_tick_height() && last_entries.is_none(), - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -204,7 +204,7 @@ impl BroadcastRun for BroadcastDuplicatesRun { keypair, &[original_last_entry], true, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -217,7 +217,7 @@ impl BroadcastRun for BroadcastDuplicatesRun { keypair, &duplicate_extra_last_entries, true, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, diff --git a/turbine/src/broadcast_stage/broadcast_fake_shreds_run.rs b/turbine/src/broadcast_stage/broadcast_fake_shreds_run.rs index e1389dd4bb7cf0..6c70857701e263 100644 --- a/turbine/src/broadcast_stage/broadcast_fake_shreds_run.rs +++ b/turbine/src/broadcast_stage/broadcast_fake_shreds_run.rs @@ -83,7 +83,7 @@ impl BroadcastRun for BroadcastFakeShredsRun { keypair, &receive_results.entries, last_tick_height == bank.max_tick_height(), - Some(chained_merkle_root), + chained_merkle_root, next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -104,7 +104,7 @@ impl BroadcastRun for BroadcastFakeShredsRun { keypair, &fake_entries, last_tick_height == bank.max_tick_height(), - Some(chained_merkle_root), + chained_merkle_root, next_shred_index, self.next_code_index, &self.reed_solomon_cache, diff --git a/turbine/src/broadcast_stage/fail_entry_verification_broadcast_run.rs b/turbine/src/broadcast_stage/fail_entry_verification_broadcast_run.rs index 3ac6b202175e13..37e94fb3ad21dd 100644 --- a/turbine/src/broadcast_stage/fail_entry_verification_broadcast_run.rs +++ b/turbine/src/broadcast_stage/fail_entry_verification_broadcast_run.rs @@ -105,7 +105,7 @@ impl BroadcastRun for FailEntryVerificationBroadcastRun { keypair, &receive_results.entries, last_tick_height == bank.max_tick_height() && last_entries.is_none(), - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -124,7 +124,7 @@ impl BroadcastRun for FailEntryVerificationBroadcastRun { keypair, &[good_last_entry], true, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -137,7 +137,7 @@ impl BroadcastRun for FailEntryVerificationBroadcastRun { keypair, &[bad_last_entry], false, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, diff --git a/turbine/src/retransmit_stage.rs b/turbine/src/retransmit_stage.rs index 05e72c6e8e33cb..0f56b0cb6d4f80 100644 --- a/turbine/src/retransmit_stage.rs +++ b/turbine/src/retransmit_stage.rs @@ -917,7 +917,7 @@ mod tests { &entries, true, // chained_merkle_root - Some(Hash::new_from_array(rand::thread_rng().gen())), + Hash::new_from_array(rand::thread_rng().gen()), 0, code_index, &rsc, diff --git a/turbine/src/sigverify_shreds.rs b/turbine/src/sigverify_shreds.rs index 907bb1fe5539ca..abffe86b165065 100644 --- a/turbine/src/sigverify_shreds.rs +++ b/turbine/src/sigverify_shreds.rs @@ -599,7 +599,7 @@ mod tests { &leader_keypair, &entries, true, - Some(Hash::new_unique()), + Hash::new_unique(), 0, 0, &ReedSolomonCache::default(), @@ -609,7 +609,7 @@ mod tests { &wrong_keypair, &entries, true, - Some(Hash::new_unique()), + Hash::new_unique(), 0, 0, &ReedSolomonCache::default(), From f96e47dd006efc4ba97ddc1ff96bd8691442c4e2 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 10:36:31 +0200 Subject: [PATCH 10/13] remove chained switch in sigverify_shreds/make_shreds --- ledger/src/sigverify_shreds.rs | 30 ++++++++++++------------------ 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/ledger/src/sigverify_shreds.rs b/ledger/src/sigverify_shreds.rs index 78d138b24c1316..9e055f86f37b8b 100644 --- a/ledger/src/sigverify_shreds.rs +++ b/ledger/src/sigverify_shreds.rs @@ -542,7 +542,7 @@ mod tests { solana_system_transaction as system_transaction, solana_transaction::Transaction, std::iter::{once, repeat_with}, - test_case::test_matrix, + test_case::test_case, }; fn run_test_sigverify_shred_cpu(slot: Slot) { @@ -740,7 +740,6 @@ mod tests { fn make_shreds( rng: &mut R, - chained: bool, is_last_in_slot: bool, keypairs: &HashMap, ) -> Vec { @@ -761,10 +760,9 @@ mod tests { keypair, &make_entries(rng, num_entries), is_last_in_slot, - // chained_merkle_root - chained.then(|| Hash::new_from_array(rng.gen())), - rng.gen_range(0..2671), // next_shred_index - rng.gen_range(0..2781), // next_code_index + Some(Hash::new_from_array(rng.gen())), // chained_merkle_root + rng.gen_range(0..2671), // next_shred_index + rng.gen_range(0..2781), // next_code_index &reed_solomon_cache, &mut ProcessShredsStats::default(), ) @@ -811,11 +809,9 @@ mod tests { packets } - #[test_matrix( - [true, false], - [true, false] - )] - fn test_verify_shreds_fuzz(chained: bool, is_last_in_slot: bool) { + #[test_case(true)] + #[test_case(false)] + fn test_verify_shreds_fuzz(is_last_in_slot: bool) { let mut rng = rand::thread_rng(); let cache = RwLock::new(LruCache::new(/*capacity:*/ 128)); let thread_pool = ThreadPoolBuilder::new().num_threads(3).build().unwrap(); @@ -824,7 +820,7 @@ mod tests { .map(|slot| (slot, Keypair::new())) .take(3) .collect(); - let shreds = make_shreds(&mut rng, chained, is_last_in_slot, &keypairs); + let shreds = make_shreds(&mut rng, is_last_in_slot, &keypairs); let pubkeys: SlotPubkeys = keypairs .iter() .map(|(&slot, keypair)| (slot, keypair.pubkey())) @@ -863,11 +859,9 @@ mod tests { ); } - #[test_matrix( - [true, false], - [true, false] - )] - fn test_sign_shreds_gpu(chained: bool, is_last_in_slot: bool) { + #[test_case(true)] + #[test_case(false)] + fn test_sign_shreds_gpu(is_last_in_slot: bool) { let mut rng = rand::thread_rng(); let cache = RwLock::new(LruCache::new(/*capacity:*/ 128)); let thread_pool = ThreadPoolBuilder::new().num_threads(3).build().unwrap(); @@ -877,7 +871,7 @@ mod tests { .map(|slot| (slot, Keypair::new())) .take(3) .collect(); - make_shreds(&mut rng, chained, is_last_in_slot, &keypairs) + make_shreds(&mut rng, is_last_in_slot, &keypairs) }; let keypair = Keypair::new(); let pubkeys: SlotPubkeys = { From 2e0732e101f4b7be55c56f4488e362e90b6f353b Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 11:06:41 +0200 Subject: [PATCH 11/13] remove option from chained_merkle_root in shredder/make_merkle_shreds_from_entries --- core/benches/shredder.rs | 6 +++--- ledger-tool/src/bigtable.rs | 8 ++++---- ledger/src/blockstore.rs | 19 +++++++++---------- ledger/src/shredder.rs | 6 +++--- ledger/src/sigverify_shreds.rs | 6 +++--- turbine/benches/cluster_info.rs | 8 ++++---- turbine/benches/cluster_nodes.rs | 11 +++++------ .../broadcast_stage/standard_broadcast_run.rs | 4 ++-- turbine/src/sigverify_shreds.rs | 3 +-- 9 files changed, 34 insertions(+), 37 deletions(-) diff --git a/core/benches/shredder.rs b/core/benches/shredder.rs index cecaba7f214830..24c23186d74fba 100644 --- a/core/benches/shredder.rs +++ b/core/benches/shredder.rs @@ -128,7 +128,7 @@ fn bench_deserialize_hdr(bencher: &mut Bencher) { &keypair, &[], true, // is_last_in_slot - Some(merkle_root), + merkle_root, 1, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -162,7 +162,7 @@ fn bench_shredder_coding(bencher: &mut Bencher) { &Keypair::new(), &entries, true, // is_last_in_slot - Some(merkle_root), + merkle_root, 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -184,7 +184,7 @@ fn bench_shredder_decoding(bencher: &mut Bencher) { &Keypair::new(), &entries, true, // is_last_in_slot - Some(merkle_root), + merkle_root, 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, diff --git a/ledger-tool/src/bigtable.rs b/ledger-tool/src/bigtable.rs index e27af5d234fa38..f7d638c843f2f1 100644 --- a/ledger-tool/src/bigtable.rs +++ b/ledger-tool/src/bigtable.rs @@ -393,10 +393,10 @@ async fn shreds( .make_merkle_shreds_from_entries( &keypair, &entries, - true, // last_in_slot - None, // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + true, // last_in_slot + Hash::default(), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ) diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index e2c9e77f3a32f4..38a4d5ed904a49 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -2424,7 +2424,7 @@ impl Blockstore { keypair, &slot_entries, is_full_slot, - Some(chained_merkle_root), + chained_merkle_root, 0, // next_shred_index 0, // next_code_index &reed_solomon_cache, @@ -5094,10 +5094,9 @@ pub fn entries_to_test_shreds( &Keypair::new(), entries, is_full_slot, - // chained_merkle_root - Some(Hash::new_from_array(rand::thread_rng().gen())), - 0, // next_shred_index, - 0, // next_code_index + Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root + 0, // next_shred_index, + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ) @@ -10736,10 +10735,10 @@ pub mod tests { .make_merkle_shreds_from_entries( &leader_keypair, &entries, - true, // is_last_in_slot - Some(Hash::new_unique()), - 0, // next_shred_index - 0, // next_code_index, + true, // is_last_in_slot + Hash::new_unique(), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index, &reed_solomon_cache, &mut ProcessShredsStats::default(), ) @@ -10752,7 +10751,7 @@ pub mod tests { &leader_keypair, &entries, true, // is_last_in_slot - Some(last_data1.chained_merkle_root().unwrap()), + last_data1.chained_merkle_root().unwrap(), last_data1.index() + 1, // next_shred_index last_code1.index() + 1, // next_code_index, &reed_solomon_cache, diff --git a/ledger/src/shredder.rs b/ledger/src/shredder.rs index 3d1f3b2581133b..46d737d8dbbc52 100644 --- a/ledger/src/shredder.rs +++ b/ledger/src/shredder.rs @@ -69,7 +69,7 @@ impl Shredder { keypair: &Keypair, entries: &[Entry], is_last_in_slot: bool, - chained_merkle_root: Option, + chained_merkle_root: Hash, next_shred_index: u32, next_code_index: u32, reed_solomon_cache: &ReedSolomonCache, @@ -83,7 +83,7 @@ impl Shredder { keypair, &entries, is_last_in_slot, - chained_merkle_root, + Some(chained_merkle_root), next_shred_index, next_code_index, reed_solomon_cache, @@ -141,7 +141,7 @@ impl Shredder { keypair, entries, is_last_in_slot, - Some(chained_merkle_root), + chained_merkle_root, next_shred_index, next_code_index, reed_solomon_cache, diff --git a/ledger/src/sigverify_shreds.rs b/ledger/src/sigverify_shreds.rs index 9e055f86f37b8b..5184e10cb9200e 100644 --- a/ledger/src/sigverify_shreds.rs +++ b/ledger/src/sigverify_shreds.rs @@ -760,9 +760,9 @@ mod tests { keypair, &make_entries(rng, num_entries), is_last_in_slot, - Some(Hash::new_from_array(rng.gen())), // chained_merkle_root - rng.gen_range(0..2671), // next_shred_index - rng.gen_range(0..2781), // next_code_index + Hash::new_from_array(rng.gen()), // chained_merkle_root + rng.gen_range(0..2671), // next_shred_index + rng.gen_range(0..2781), // next_code_index &reed_solomon_cache, &mut ProcessShredsStats::default(), ) diff --git a/turbine/benches/cluster_info.rs b/turbine/benches/cluster_info.rs index 983a637c00e2b5..ffd221aad0dc71 100644 --- a/turbine/benches/cluster_info.rs +++ b/turbine/benches/cluster_info.rs @@ -57,10 +57,10 @@ fn broadcast_shreds_bench(b: &mut Bencher) { let data_shreds = shredder.make_merkle_shreds_from_entries( &leader_keypair, &entries, - true, // is_last_in_slot - None, // chained_merkle_root - 0, // next_shred_index - 0, // next_code_index + true, // is_last_in_slot + Hash::default(), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &ReedSolomonCache::default(), &mut ProcessShredsStats::default(), ); diff --git a/turbine/benches/cluster_nodes.rs b/turbine/benches/cluster_nodes.rs index a34fd227180bb7..8cd65c90bb5935 100644 --- a/turbine/benches/cluster_nodes.rs +++ b/turbine/benches/cluster_nodes.rs @@ -32,7 +32,6 @@ fn get_retransmit_peers_deterministic( slot_leader: &Pubkey, ) { let keypair = Keypair::new(); - let merkle_root = Some(Hash::default()); let reed_solomon_cache = ReedSolomonCache::default(); let mut stats = ProcessShredsStats::default(); let parent_slot = if slot > 0 { slot - 1 } else { 0 }; @@ -40,11 +39,11 @@ fn get_retransmit_peers_deterministic( let shreds = shredder.make_merkle_shreds_from_entries( &keypair, - &[], // entries - true, // is_last_in_slot - merkle_root, - 0, // next_shred_index - 0, // next_code_index + &[], // entries + true, // is_last_in_slot + Hash::default(), // chained_merkle_root + 0, // next_shred_index + 0, // next_code_index &reed_solomon_cache, &mut stats, ); diff --git a/turbine/src/broadcast_stage/standard_broadcast_run.rs b/turbine/src/broadcast_stage/standard_broadcast_run.rs index a178ac8324a84c..2d11108a1682db 100644 --- a/turbine/src/broadcast_stage/standard_broadcast_run.rs +++ b/turbine/src/broadcast_stage/standard_broadcast_run.rs @@ -92,7 +92,7 @@ impl StandardBroadcastRun { keypair, &[], // entries true, // is_last_in_slot, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, @@ -126,7 +126,7 @@ impl StandardBroadcastRun { keypair, entries, is_slot_end, - Some(self.chained_merkle_root), + self.chained_merkle_root, self.next_shred_index, self.next_code_index, &self.reed_solomon_cache, diff --git a/turbine/src/sigverify_shreds.rs b/turbine/src/sigverify_shreds.rs index abffe86b165065..324c2c425091d7 100644 --- a/turbine/src/sigverify_shreds.rs +++ b/turbine/src/sigverify_shreds.rs @@ -662,8 +662,7 @@ mod tests { let bank_forks = bank_forks.read().unwrap(); (bank_forks.working_bank(), bank_forks.root_bank()) }; - - let chained_merkle_root = Some(Hash::new_from_array(rng.gen())); + let chained_merkle_root = Hash::new_from_array(rng.gen()); let shredder = Shredder::new(root_bank.slot(), root_bank.parent_slot(), 0, 0).unwrap(); let entries = vec![Entry::new(&Hash::default(), 0, vec![])]; From 69626b710afdf0da74733fbb181de56a15b94ca0 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 16:04:58 +0200 Subject: [PATCH 12/13] remove option from chained_merkle_root in shredder/make_shreds_from_data_slice --- core/src/replay_stage.rs | 2 +- ledger/src/blockstore.rs | 6 +++--- ledger/src/shred.rs | 2 +- ledger/src/shredder.rs | 6 +++--- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/core/src/replay_stage.rs b/core/src/replay_stage.rs index 9ccb092cc86b4f..88bfcc5caa2ade 100644 --- a/core/src/replay_stage.rs +++ b/core/src/replay_stage.rs @@ -5106,7 +5106,7 @@ pub(crate) mod tests { &keypair, &gibberish, true, - Some(Hash::default()), + Hash::default(), 0, 0, &reed_solomon_cache, diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index 38a4d5ed904a49..6752e302fdf8e8 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -6876,7 +6876,7 @@ pub mod tests { &keypair, &[], false, - Some(Hash::default()), // merkle_root + Hash::default(), // merkle_root (i * gap) as u32, (i * gap) as u32, &reed_solomon_cache, @@ -7543,7 +7543,7 @@ pub mod tests { &keypair, &[3, 3, 3], false, - Some(Hash::default()), + Hash::default(), new_index, new_index, &reed_solomon_cache, @@ -7886,7 +7886,7 @@ pub mod tests { &keypair, &[1, 1, 1], true, - Some(Hash::default()), + Hash::default(), next_shred_index as u32, next_shred_index as u32, &reed_solomon_cache, diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index ceb65a30047928..fa6fbb8e03a757 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -1807,7 +1807,7 @@ mod tests { &keypair, &data, false, - Some(Hash::default()), + Hash::default(), 64, 64, &reed_solomon_cache, diff --git a/ledger/src/shredder.rs b/ledger/src/shredder.rs index 46d737d8dbbc52..9b3a3e55c355c6 100644 --- a/ledger/src/shredder.rs +++ b/ledger/src/shredder.rs @@ -83,7 +83,7 @@ impl Shredder { keypair, &entries, is_last_in_slot, - Some(chained_merkle_root), + chained_merkle_root, next_shred_index, next_code_index, reed_solomon_cache, @@ -98,7 +98,7 @@ impl Shredder { keypair: &Keypair, data: &[u8], is_last_in_slot: bool, - chained_merkle_root: Option, + chained_merkle_root: Hash, next_shred_index: u32, next_code_index: u32, reed_solomon_cache: &ReedSolomonCache, @@ -108,7 +108,7 @@ impl Shredder { let shreds = shred::merkle::make_shreds_from_data( thread_pool, keypair, - chained_merkle_root, + Some(chained_merkle_root), data, self.slot, self.parent_slot, From e3d4e4f0b62c8899a5d5ae49e0b4182190017505 Mon Sep 17 00:00:00 2001 From: marc Date: Thu, 18 Sep 2025 17:09:13 +0200 Subject: [PATCH 13/13] remove chained param from ledger/shred/make_merkle_shreds_for_tests --- ledger/src/shred.rs | 9 ++------- ledger/src/shred/wire.rs | 32 ++++++++++++-------------------- 2 files changed, 14 insertions(+), 27 deletions(-) diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index fa6fbb8e03a757..4468aa172387f2 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -1014,11 +1014,10 @@ mod tests { rng: &mut R, slot: Slot, data_size: usize, - chained: bool, is_last_in_slot: bool, ) -> Result, Error> { let thread_pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap(); - let chained_merkle_root = chained.then(|| Hash::new_from_array(rng.gen())); + let chained_merkle_root = Hash::new_from_array(rng.gen()); let parent_offset = rng.gen_range(1..=u16::try_from(slot).unwrap_or(u16::MAX)); let parent_slot = slot.checked_sub(u64::from(parent_offset)).unwrap(); let mut data = vec![0u8; data_size]; @@ -1027,7 +1026,7 @@ mod tests { merkle::make_shreds_from_data( &thread_pool, &Keypair::new(), - chained_merkle_root, + Some(chained_merkle_root), &data[..], slot, parent_slot, @@ -1168,7 +1167,6 @@ mod tests { &mut rng, slot, 1200 * 5, // data_size - true, // chained is_last_in_slot, ) .unwrap(); @@ -1418,7 +1416,6 @@ mod tests { &mut rng, slot, 1200 * 5, // data_size - true, // chained false, // is_last_in_slot ) .unwrap(); @@ -1526,7 +1523,6 @@ mod tests { &mut rng, slot, 1200 * 5, // data_size - true, // chained true, // is_last_in_slot ) .unwrap(); @@ -1966,7 +1962,6 @@ mod tests { &mut rng, slot, 1200 * 5, // data_size - true, is_last_in_slot, ) .unwrap() diff --git a/ledger/src/shred/wire.rs b/ledger/src/shred/wire.rs index 3c618777117f71..0e74997f36a0e6 100644 --- a/ledger/src/shred/wire.rs +++ b/ledger/src/shred/wire.rs @@ -471,17 +471,15 @@ mod tests { } #[test_matrix( - [true, false], [true, false], [true, false] )] - fn test_resign_packet(repaired: bool, chained: bool, is_last_in_slot: bool) { + fn test_resign_packet(repaired: bool, is_last_in_slot: bool) { let mut rng = rand::thread_rng(); let slot = 318_230_963 + rng.gen_range(0..318_230_963); let data_size = 1200 * rng.gen_range(32..64); let mut shreds = - make_merkle_shreds_for_tests(&mut rng, slot, data_size, chained, is_last_in_slot) - .unwrap(); + make_merkle_shreds_for_tests(&mut rng, slot, data_size, is_last_in_slot).unwrap(); // enumerate the shreds so that I have index of each shred let shreds_len = shreds.len(); for (index, shred) in shreds.iter_mut().enumerate() { @@ -489,7 +487,7 @@ mod tests { let signature = make_dummy_signature(&mut rng); let nonce = repaired.then(|| rng.gen::()); let is_last_batch = index >= shreds_len - SHREDS_PER_FEC_BLOCK; - if chained && is_last_in_slot && is_last_batch { + if is_last_in_slot && is_last_batch { shred.set_retransmitter_signature(&signature).unwrap(); let packet = &mut shred.payload().to_packet(nonce); @@ -531,22 +529,20 @@ mod tests { } #[test_matrix( - [true, false], [true, false], [true, false] )] - fn test_merkle_shred_wire_layout(repaired: bool, chained: bool, is_last_in_slot: bool) { + fn test_merkle_shred_wire_layout(repaired: bool, is_last_in_slot: bool) { let mut rng = rand::thread_rng(); let slot = 318_230_963 + rng.gen_range(0..318_230_963); let data_size = 1200 * rng.gen_range(32..64); let mut shreds = - make_merkle_shreds_for_tests(&mut rng, slot, data_size, chained, is_last_in_slot) - .unwrap(); + make_merkle_shreds_for_tests(&mut rng, slot, data_size, is_last_in_slot).unwrap(); let shreds_len = shreds.len(); for (index, shred) in shreds.iter_mut().enumerate() { let signature = make_dummy_signature(&mut rng); let is_last_batch = index >= shreds_len - SHREDS_PER_FEC_BLOCK; - if chained && is_last_in_slot && is_last_batch { + if is_last_in_slot && is_last_batch { shred.set_retransmitter_signature(&signature).unwrap(); } else { assert_matches!( @@ -607,19 +603,15 @@ mod tests { get_merkle_root(bytes).unwrap(), shred.merkle_root().unwrap(), ); - if chained { - assert_eq!( - get_chained_merkle_root(bytes).unwrap(), - shred.chained_merkle_root().unwrap(), - ); - } else { - assert_matches!(get_chained_merkle_root(bytes), None); - } + assert_eq!( + get_chained_merkle_root(bytes).unwrap(), + shred.chained_merkle_root().unwrap(), + ); assert_eq!( is_retransmitter_signed_variant(bytes).unwrap(), - chained && is_last_in_slot && is_last_batch, + is_last_in_slot && is_last_batch, ); - if chained && is_last_in_slot && is_last_batch { + if is_last_in_slot && is_last_batch { assert_eq!( get_retransmitter_signature_offset(bytes).unwrap(), shred.retransmitter_signature_offset().unwrap(),