jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 19:09:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Implement "Add BlockBody::transaction_count helper function" (#13660)

Browse Source
This commit is contained in:
Udoagwa Franklin
2025-01-05 15:31:20 +01:00
committed by GitHub
parent bfa97c1522
commit f4ce10b7f0
15 changed files with 63 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crates/primitives-traits/src/block/body.rs
View File

@ -46,6 +46,10 @@ pub trait BlockBody:
self.transactions().iter().map(|tx| tx.tx_hash())
}
/// Returns the number of the transactions in the block.
fn transaction_count(&self) -> usize {
self.transactions().len()
}
/// Consume the block body and return a [`Vec`] of transactions.
fn into_transactions(self) -> Vec<Self::Transaction>;

21
crates/primitives/src/block.rs
View File

@ -232,6 +232,17 @@ where
}
}
impl<H, B> SealedBlock<H, B>
where
B: reth_primitives_traits::BlockBody,
{
/// Returns the number of transactions in the block.
#[inline]
pub fn transaction_count(&self) -> usize {
self.body.transaction_count()
}
}
impl<H, B> SealedBlock<H, B>
where
H: alloy_consensus::BlockHeader,
@ -918,4 +929,14 @@ mod tests {
let decoded = BlockBody::decode(&mut buf.as_slice()).unwrap();
assert_eq!(body, decoded);
}
#[test]
fn test_transaction_count() {
let mut block = Block::default();
assert_eq!(block.body.transaction_count(), 0);
block.body.transactions.push(TransactionSigned::default());
assert_eq!(block.body.transaction_count(), 1);
block.body.transactions.push(TransactionSigned::default());
assert_eq!(block.body.transaction_count(), 2);
}
}

9
crates/prune/prune/src/segments/mod.rs
View File

@ -242,8 +242,7 @@ mod tests {
let range = input.get_next_tx_num_range(&provider).expect("Expected range").unwrap();
// Calculate the total number of transactions
let num_txs =
blocks.iter().map(|block| block.body().transactions.len() as u64).sum::<u64>();
let num_txs = blocks.iter().map(|block| block.transaction_count() as u64).sum::<u64>();
assert_eq!(range, 0..=num_txs - 1);
}
@ -289,8 +288,7 @@ mod tests {
let range = input.get_next_tx_num_range(&provider).expect("Expected range").unwrap();
// Calculate the total number of transactions
let num_txs =
blocks.iter().map(|block| block.body().transactions.len() as u64).sum::<u64>();
let num_txs = blocks.iter().map(|block| block.transaction_count() as u64).sum::<u64>();
assert_eq!(range, 0..=num_txs - 1,);
}
@ -324,8 +322,7 @@ mod tests {
// Get the last tx number
// Calculate the total number of transactions
let num_txs =
blocks.iter().map(|block| block.body().transactions.len() as u64).sum::<u64>();
let num_txs = blocks.iter().map(|block| block.transaction_count() as u64).sum::<u64>();
let max_range = num_txs - 1;
// Create a prune input with a previous checkpoint that is the last tx number

8
crates/prune/prune/src/segments/receipts.rs
View File

@ -113,7 +113,7 @@ mod tests {
let mut receipts = Vec::new();
for block in &blocks {
receipts.reserve_exact(block.body().transactions.len());
receipts.reserve_exact(block.transaction_count());
for transaction in &block.body().transactions {
receipts
.push((receipts.len() as u64, random_receipt(&mut rng, transaction, Some(0))));
@ -124,7 +124,7 @@ mod tests {
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
blocks.iter().map(|block| block.body().transactions.len()).sum::<usize>()
blocks.iter().map(|block| block.transaction_count()).sum::<usize>()
);
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
@ -158,7 +158,7 @@ mod tests {
let last_pruned_tx_number = blocks
.iter()
.take(to_block as usize)
.map(|block| block.body().transactions.len())
.map(|block| block.transaction_count())
.sum::<usize>()
.min(
next_tx_number_to_prune as usize +
@ -186,7 +186,7 @@ mod tests {
let last_pruned_block_number = blocks
.iter()
.fold_while((0, 0), |(_, mut tx_count), block| {
tx_count += block.body().transactions.len();
tx_count += block.transaction_count();
if tx_count > last_pruned_tx_number {
Done((block.number, tx_count))

4
crates/prune/prune/src/segments/static_file/transactions.rs
View File

@ -174,7 +174,7 @@ mod tests {
let last_pruned_tx_number = blocks
.iter()
.take(to_block as usize)
.map(|block| block.body().transactions.len())
.map(|block| block.transaction_count())
.sum::<usize>()
.min(
next_tx_number_to_prune as usize +
@ -185,7 +185,7 @@ mod tests {
let last_pruned_block_number = blocks
.iter()
.fold_while((0, 0), |(_, mut tx_count), block| {
tx_count += block.body().transactions.len();
tx_count += block.transaction_count();
if tx_count > last_pruned_tx_number {
Done((block.number, tx_count))

6
crates/prune/prune/src/segments/user/receipts_by_logs.rs
View File

@ -278,7 +278,7 @@ mod tests {
let mut receipt = random_receipt(&mut rng, transaction, Some(1));
receipt.logs.push(random_log(
&mut rng,
(txi == (block.body().transactions.len() - 1)).then_some(deposit_contract_addr),
(txi == (block.transaction_count() - 1)).then_some(deposit_contract_addr),
Some(1),
));
receipts.push((receipts.len() as u64, receipt));
@ -288,7 +288,7 @@ mod tests {
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
blocks.iter().map(|block| block.body().transactions.len()).sum::<usize>()
blocks.iter().map(|block| block.transaction_count()).sum::<usize>()
);
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
@ -337,7 +337,7 @@ mod tests {
assert_eq!(
db.table::<tables::Receipts>().unwrap().len(),
blocks.iter().map(|block| block.body().transactions.len()).sum::<usize>() -
blocks.iter().map(|block| block.transaction_count()).sum::<usize>() -
((pruned_tx + 1) - unprunable) as usize
);

8
crates/prune/prune/src/segments/user/sender_recovery.rs
View File

@ -111,7 +111,7 @@ mod tests {
let mut transaction_senders = Vec::new();
for block in &blocks {
transaction_senders.reserve_exact(block.body().transactions.len());
transaction_senders.reserve_exact(block.transaction_count());
for transaction in &block.body().transactions {
transaction_senders.push((
transaction_senders.len() as u64,
@ -124,7 +124,7 @@ mod tests {
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
blocks.iter().map(|block| block.body().transactions.len()).sum::<usize>()
blocks.iter().map(|block| block.transaction_count()).sum::<usize>()
);
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
@ -159,7 +159,7 @@ mod tests {
let last_pruned_tx_number = blocks
.iter()
.take(to_block as usize)
.map(|block| block.body().transactions.len())
.map(|block| block.transaction_count())
.sum::<usize>()
.min(
next_tx_number_to_prune as usize +
@ -170,7 +170,7 @@ mod tests {
let last_pruned_block_number = blocks
.iter()
.fold_while((0, 0), |(_, mut tx_count), block| {
tx_count += block.body().transactions.len();
tx_count += block.transaction_count();
if tx_count > last_pruned_tx_number {
Done((block.number, tx_count))

8
crates/prune/prune/src/segments/user/transaction_lookup.rs
View File

@ -139,7 +139,7 @@ mod tests {
let mut tx_hash_numbers = Vec::new();
for block in &blocks {
tx_hash_numbers.reserve_exact(block.body().transactions.len());
tx_hash_numbers.reserve_exact(block.transaction_count());
for transaction in &block.body().transactions {
tx_hash_numbers.push((transaction.hash(), tx_hash_numbers.len() as u64));
}
@ -149,7 +149,7 @@ mod tests {
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
blocks.iter().map(|block| block.body().transactions.len()).sum::<usize>()
blocks.iter().map(|block| block.transaction_count()).sum::<usize>()
);
assert_eq!(
db.table::<tables::Transactions>().unwrap().len(),
@ -184,7 +184,7 @@ mod tests {
let last_pruned_tx_number = blocks
.iter()
.take(to_block as usize)
.map(|block| block.body().transactions.len())
.map(|block| block.transaction_count())
.sum::<usize>()
.min(
next_tx_number_to_prune as usize +
@ -195,7 +195,7 @@ mod tests {
let last_pruned_block_number = blocks
.iter()
.fold_while((0, 0), |(_, mut tx_count), block| {
tx_count += block.body().transactions.len();
tx_count += block.transaction_count();
if tx_count > last_pruned_tx_number {
Done((block.number, tx_count))

2
crates/stages/stages/src/stages/bodies.rs
View File

@ -592,7 +592,7 @@ mod tests {
let body = StoredBlockBodyIndices {
first_tx_num: 0,
tx_count: progress.body().transactions.len() as u64,
tx_count: progress.transaction_count() as u64,
};
static_file_producer.set_block_range(0..=progress.number);

2
crates/stages/stages/src/stages/hashing_storage.rs
View File

@ -398,7 +398,7 @@ mod tests {
let body = StoredBlockBodyIndices {
first_tx_num,
tx_count: progress.body().transactions.len() as u64,
tx_count: progress.transaction_count() as u64,
};
first_tx_num = next_tx_num;

2
crates/stages/stages/src/stages/mod.rs
View File

@ -267,7 +267,7 @@ mod tests {
let mut receipts = Vec::with_capacity(blocks.len());
let mut tx_num = 0u64;
for block in &blocks {
let mut block_receipts = Vec::with_capacity(block.body().transactions.len());
let mut block_receipts = Vec::with_capacity(block.transaction_count());
for transaction in &block.body().transactions {
block_receipts.push((tx_num, random_receipt(&mut rng, transaction, Some(0))));
tx_num += 1;

8
crates/stages/stages/src/stages/sender_recovery.rs
View File

@ -477,7 +477,7 @@ mod tests {
let expected_progress = seed
.iter()
.find(|x| {
tx_count += x.body().transactions.len();
tx_count += x.transaction_count();
tx_count as u64 > threshold
})
.map(|x| x.number)
@ -555,7 +555,7 @@ mod tests {
tx_number: Some(
blocks[..=max_pruned_block as usize]
.iter()
.map(|block| block.body().transactions.len() as u64)
.map(|block| block.transaction_count() as u64)
.sum(),
),
prune_mode: PruneMode::Full,
@ -570,9 +570,9 @@ mod tests {
EntitiesCheckpoint {
processed: blocks[..=max_processed_block]
.iter()
.map(|block| block.body().transactions.len() as u64)
.map(|block| block.transaction_count() as u64)
.sum(),
total: blocks.iter().map(|block| block.body().transactions.len() as u64).sum()
total: blocks.iter().map(|block| block.transaction_count() as u64).sum()
}
);
}

6
crates/stages/stages/src/stages/tx_lookup.rs
View File

@ -403,7 +403,7 @@ mod tests {
tx_number: Some(
blocks[..=max_pruned_block as usize]
.iter()
.map(|block| block.body().transactions.len() as u64)
.map(|block| block.transaction_count() as u64)
.sum::<u64>()
.sub(1), // `TxNumber` is 0-indexed
),
@ -419,9 +419,9 @@ mod tests {
EntitiesCheckpoint {
processed: blocks[..=max_processed_block]
.iter()
.map(|block| block.body().transactions.len() as u64)
.map(|block| block.transaction_count() as u64)
.sum(),
total: blocks.iter().map(|block| block.body().transactions.len() as u64).sum()
total: blocks.iter().map(|block| block.transaction_count() as u64).sum()
}
);
}

4
crates/stages/stages/src/test_utils/test_db.rs
View File

@ -252,7 +252,7 @@ impl TestStageDB {
// Insert into body tables.
let block_body_indices = StoredBlockBodyIndices {
first_tx_num: next_tx_num,
tx_count: block.body().transactions.len() as u64,
tx_count: block.transaction_count() as u64,
};
if !block.body().transactions.is_empty() {
@ -489,7 +489,7 @@ impl StorageKind {
fn tx_offset(&self) -> u64 {
if let Self::Database(offset) = self {
return offset.unwrap_or_default()
return offset.unwrap_or_default();
}
0
}

12
crates/storage/provider/src/providers/blockchain_provider.rs
View File

@ -2167,9 +2167,9 @@ mod tests {
$(
// Since data moves for each tried method, need to recalculate everything
let db_tx_count =
database_blocks.iter().map(|b| b.body().transactions.len()).sum::<usize>() as u64;
database_blocks.iter().map(|b| b.transaction_count()).sum::<usize>() as u64;
let in_mem_tx_count =
in_memory_blocks.iter().map(|b| b.body().transactions.len()).sum::<usize>() as u64;
in_memory_blocks.iter().map(|b| b.transaction_count()).sum::<usize>() as u64;
let db_range = 0..=(db_tx_count - 1);
let in_mem_range = db_tx_count..=(in_mem_tx_count + db_range.end());
@ -2410,7 +2410,7 @@ mod tests {
.iter()
.chain(in_memory_blocks.iter())
.take_while(|b| b.number < block.number)
.map(|b| b.body().transactions.len())
.map(|b| b.transaction_count())
.sum::<usize>() as u64
};
@ -2431,7 +2431,7 @@ mod tests {
.iter()
.chain(in_memory_blocks.iter())
.take_while(|b| b.number < block.number)
.map(|b| b.body().transactions.len())
.map(|b| b.transaction_count())
.sum::<usize>() as u64
};
@ -2527,7 +2527,7 @@ mod tests {
block.number,
Some(StoredBlockBodyIndices {
first_tx_num: tx_num,
tx_count: block.body().transactions.len() as u64
tx_count: block.transaction_count() as u64
})
),
u64::MAX
@ -2725,7 +2725,7 @@ mod tests {
canonical_in_memory_state: CanonicalInMemoryState,
_factory: ProviderFactory<MockNodeTypesWithDB>| {
if let Some(tx) = canonical_in_memory_state.transaction_by_hash(hash) {
return Ok::<_, ProviderError>(Some(tx))
return Ok::<_, ProviderError>(Some(tx));
}
panic!("should not be in database");
// _factory.transaction_by_hash(hash)