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

refactor(provider): random_block and random_block_range functions (#10563)

Browse Source
This commit is contained in:
Jennifer
2024-08-27 15:19:43 +01:00
committed by GitHub
parent 7df7bc2c1a
commit 7ea748e2d3
28 changed files with 505 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
crates/stages/stages/benches/setup/mod.rs
View File

@ -11,12 +11,9 @@ use reth_stages::{
stages::{AccountHashingStage, StorageHashingStage},
test_utils::{StorageKind, TestStageDB},
};
use reth_testing_utils::{
generators,
generators::{
random_block_range, random_changeset_range, random_contract_account_range,
random_eoa_accounts,
},
use reth_testing_utils::generators::{
self, random_block_range, random_changeset_range, random_contract_account_range,
random_eoa_accounts, BlockRangeParams,
};
use reth_trie::StateRoot;
use std::{collections::BTreeMap, fs, path::Path, sync::Arc};
@ -116,8 +113,15 @@ pub(crate) fn txs_testdata(num_blocks: u64) -> TestStageDB {
.into_iter()
.collect();
let mut blocks =
random_block_range(&mut rng, 0..=num_blocks, B256::ZERO, txs_range, None, None);
let mut blocks = random_block_range(
&mut rng,
0..=num_blocks,
BlockRangeParams {
parent: Some(B256::ZERO),
tx_count: txs_range,
..Default::default()
},
);
let (transitions, start_state) = random_changeset_range(
&mut rng,

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

@ -640,9 +640,8 @@ mod tests {
StaticFileProviderFactory, TransactionsProvider,
};
use reth_stages_api::{ExecInput, ExecOutput, UnwindInput};
use reth_testing_utils::{
generators,
generators::{random_block_range, random_signed_tx},
use reth_testing_utils::generators::{
self, random_block_range, random_signed_tx, BlockRangeParams,
};
use std::{
collections::{HashMap, VecDeque},
@ -719,7 +718,15 @@ mod tests {
let mut rng = generators::rng();
// Static files do not support gaps in headers, so we need to generate 0 to end
let blocks = random_block_range(&mut rng, 0..=end, GENESIS_HASH, 0..2, None, None);
let blocks = random_block_range(
&mut rng,
0..=end,
BlockRangeParams {
parent: Some(GENESIS_HASH),
tx_count: 0..2,
..Default::default()
},
);
self.db.insert_headers_with_td(blocks.iter().map(|block| &block.header))?;
if let Some(progress) = blocks.get(start as usize) {
// Insert last progress data

9
crates/stages/stages/src/stages/hashing_account.rs
View File

@ -67,13 +67,16 @@ impl AccountHashingStage {
use reth_provider::providers::StaticFileWriter;
use reth_testing_utils::{
generators,
generators::{random_block_range, random_eoa_accounts},
generators::{random_block_range, random_eoa_accounts, BlockRangeParams},
};
let mut rng = generators::rng();
let blocks =
random_block_range(&mut rng, opts.blocks.clone(), B256::ZERO, opts.txs, None, None);
let blocks = random_block_range(
&mut rng,
opts.blocks.clone(),
BlockRangeParams { parent: Some(B256::ZERO), tx_count: opts.txs, ..Default::default() },
);
for block in blocks {
provider.insert_historical_block(block.try_seal_with_senders().unwrap()).unwrap();

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

@ -223,9 +223,8 @@ mod tests {
};
use reth_primitives::{Address, SealedBlock, U256};
use reth_provider::providers::StaticFileWriter;
use reth_testing_utils::{
generators,
generators::{random_block_range, random_contract_account_range},
use reth_testing_utils::generators::{
self, random_block_range, random_contract_account_range, BlockRangeParams,
};
stage_test_suite_ext!(StorageHashingTestRunner, storage_hashing);
@ -341,8 +340,11 @@ mod tests {
let n_accounts = 31;
let mut accounts = random_contract_account_range(&mut rng, &mut (0..n_accounts));
let blocks =
random_block_range(&mut rng, stage_progress..=end, B256::ZERO, 0..3, None, None);
let blocks = random_block_range(
&mut rng,
stage_progress..=end,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..3, ..Default::default() },
);
self.db.insert_headers(blocks.iter().map(|block| &block.header))?;

12
crates/stages/stages/src/stages/index_account_history.rs
View File

@ -158,9 +158,9 @@ mod tests {
};
use reth_primitives::{address, BlockNumber, B256};
use reth_provider::providers::StaticFileWriter;
use reth_testing_utils::{
generators,
generators::{random_block_range, random_changeset_range, random_contract_account_range},
use reth_testing_utils::generators::{
self, random_block_range, random_changeset_range, random_contract_account_range,
BlockRangeParams,
};
use std::collections::BTreeMap;
@ -538,7 +538,11 @@ mod tests {
.into_iter()
.collect::<BTreeMap<_, _>>();
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3, None, None);
let blocks = random_block_range(
&mut rng,
start..=end,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..3, ..Default::default() },
);
let (changesets, _) = random_changeset_range(
&mut rng,

12
crates/stages/stages/src/stages/index_storage_history.rs
View File

@ -164,9 +164,9 @@ mod tests {
};
use reth_primitives::{address, b256, Address, BlockNumber, StorageEntry, B256, U256};
use reth_provider::providers::StaticFileWriter;
use reth_testing_utils::{
generators,
generators::{random_block_range, random_changeset_range, random_contract_account_range},
use reth_testing_utils::generators::{
self, random_block_range, random_changeset_range, random_contract_account_range,
BlockRangeParams,
};
use std::collections::BTreeMap;
@ -560,7 +560,11 @@ mod tests {
.into_iter()
.collect::<BTreeMap<_, _>>();
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3, None, None);
let blocks = random_block_range(
&mut rng,
start..=end,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..3, ..Default::default() },
);
let (changesets, _) = random_changeset_range(
&mut rng,

29
crates/stages/stages/src/stages/merkle.rs
View File

@ -370,11 +370,9 @@ mod tests {
use reth_primitives::{keccak256, SealedBlock, StaticFileSegment, StorageEntry, U256};
use reth_provider::{providers::StaticFileWriter, StaticFileProviderFactory};
use reth_stages_api::StageUnitCheckpoint;
use reth_testing_utils::{
generators,
generators::{
random_block, random_block_range, random_changeset_range, random_contract_account_range,
},
use reth_testing_utils::generators::{
self, random_block, random_block_range, random_changeset_range,
random_contract_account_range, BlockParams, BlockRangeParams,
};
use reth_trie::test_utils::{state_root, state_root_prehashed};
use std::collections::BTreeMap;
@ -499,10 +497,11 @@ mod tests {
preblocks.append(&mut random_block_range(
&mut rng,
0..=stage_progress - 1,
B256::ZERO,
0..1,
None,
None,
BlockRangeParams {
parent: Some(B256::ZERO),
tx_count: 0..1,
..Default::default()
},
));
self.db.insert_blocks(preblocks.iter(), StorageKind::Static)?;
}
@ -519,11 +518,7 @@ mod tests {
let SealedBlock { header, body, ommers, withdrawals, requests } = random_block(
&mut rng,
stage_progress,
preblocks.last().map(|b| b.hash()),
Some(0),
None,
None,
None,
BlockParams { parent: preblocks.last().map(|b| b.hash()), ..Default::default() },
);
let mut header = header.unseal();
@ -538,7 +533,11 @@ mod tests {
let head_hash = sealed_head.hash();
let mut blocks = vec![sealed_head];
blocks.extend(random_block_range(&mut rng, start..=end, head_hash, 0..3, None, None));
blocks.extend(random_block_range(
&mut rng,
start..=end,
BlockRangeParams { parent: Some(head_hash), tx_count: 0..3, ..Default::default() },
));
let last_block = blocks.last().cloned().unwrap();
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;

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

@ -70,7 +70,9 @@ mod tests {
use reth_stages_api::{
ExecInput, ExecutionStageThresholds, PipelineTarget, Stage, StageCheckpoint, StageId,
};
use reth_testing_utils::generators::{self, random_block, random_block_range, random_receipt};
use reth_testing_utils::generators::{
self, random_block, random_block_range, random_receipt, BlockRangeParams,
};
use std::{io::Write, sync::Arc};
#[tokio::test]
@ -94,8 +96,11 @@ mod tests {
let mut head = block.hash();
let mut rng = generators::rng();
for block_number in 2..=tip {
let nblock =
random_block(&mut rng, block_number, Some(head), Some(0), Some(0), None, None);
let nblock = random_block(
&mut rng,
block_number,
generators::BlockParams { parent: Some(head), ..Default::default() },
);
head = nblock.hash();
provider_rw.insert_historical_block(nblock.try_seal_with_senders().unwrap()).unwrap();
}
@ -254,7 +259,11 @@ mod tests {
let genesis_hash = B256::ZERO;
let tip = (num_blocks - 1) as u64;
let blocks = random_block_range(&mut rng, 0..=tip, genesis_hash, 2..3, None, None);
let blocks = random_block_range(
&mut rng,
0..=tip,
BlockRangeParams { parent: Some(genesis_hash), tx_count: 2..3, ..Default::default() },
);
db.insert_blocks(blocks.iter(), StorageKind::Static)?;
let mut receipts = Vec::new();

7
crates/stages/stages/src/stages/prune.rs
View File

@ -165,7 +165,7 @@ mod tests {
providers::StaticFileWriter, TransactionsProvider, TransactionsProviderExt,
};
use reth_prune::PruneMode;
use reth_testing_utils::generators::{self, random_block_range};
use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};
stage_test_suite_ext!(PruneTestRunner, prune);
@ -200,10 +200,7 @@ mod tests {
let blocks = random_block_range(
&mut rng,
input.checkpoint().block_number..=input.target(),
B256::ZERO,
1..3,
None,
None,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 1..3, ..Default::default() },
);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
self.db.insert_transaction_senders(

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

@ -289,9 +289,8 @@ mod tests {
};
use reth_prune_types::{PruneCheckpoint, PruneMode};
use reth_stages_api::StageUnitCheckpoint;
use reth_testing_utils::{
generators,
generators::{random_block, random_block_range},
use reth_testing_utils::generators::{
self, random_block, random_block_range, BlockParams, BlockRangeParams,
};
use super::*;
@ -322,11 +321,10 @@ mod tests {
random_block(
&mut rng,
number,
None,
Some((number == non_empty_block_number) as u8),
None,
None,
None,
BlockParams {
tx_count: Some((number == non_empty_block_number) as u8),
..Default::default()
},
)
})
.collect::<Vec<_>>();
@ -368,10 +366,7 @@ mod tests {
let seed = random_block_range(
&mut rng,
stage_progress + 1..=previous_stage,
B256::ZERO,
0..4,
None,
None,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..4, ..Default::default() },
); // set tx count range high enough to hit the threshold
runner
.db
@ -442,7 +437,11 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10, None, None);
let blocks = random_block_range(
&mut rng,
0..=100,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..10, ..Default::default() },
);
db.insert_blocks(blocks.iter(), StorageKind::Static).expect("insert blocks");
let max_pruned_block = 30;
@ -555,8 +554,11 @@ mod tests {
let stage_progress = input.checkpoint().block_number;
let end = input.target();
let blocks =
random_block_range(&mut rng, stage_progress..=end, B256::ZERO, 0..2, None, None);
let blocks = random_block_range(
&mut rng,
stage_progress..=end,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..2, ..Default::default() },
);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
Ok(blocks)
}

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

@ -245,9 +245,8 @@ mod tests {
use reth_primitives::{BlockNumber, SealedBlock, B256};
use reth_provider::{providers::StaticFileWriter, StaticFileProviderFactory};
use reth_stages_api::StageUnitCheckpoint;
use reth_testing_utils::{
generators,
generators::{random_block, random_block_range},
use reth_testing_utils::generators::{
self, random_block, random_block_range, BlockParams, BlockRangeParams,
};
use std::ops::Sub;
@ -273,11 +272,10 @@ mod tests {
random_block(
&mut rng,
number,
None,
Some((number == non_empty_block_number) as u8),
None,
None,
None,
BlockParams {
tx_count: Some((number == non_empty_block_number) as u8),
..Default::default()
},
)
})
.collect::<Vec<_>>();
@ -323,10 +321,7 @@ mod tests {
let seed = random_block_range(
&mut rng,
stage_progress + 1..=previous_stage,
B256::ZERO,
0..2,
None,
None,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..2, ..Default::default() },
);
runner
.db
@ -361,7 +356,11 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10, None, None);
let blocks = random_block_range(
&mut rng,
0..=100,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..10, ..Default::default() },
);
db.insert_blocks(blocks.iter(), StorageKind::Static).expect("insert blocks");
let max_pruned_block = 30;
@ -490,10 +489,7 @@ mod tests {
let blocks = random_block_range(
&mut rng,
stage_progress + 1..=end,
B256::ZERO,
0..2,
None,
None,
BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..2, ..Default::default() },
);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
Ok(blocks)