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

test(provider): RequestsProvider of BlockchainProvider2 (#10356)

Browse Source
This commit is contained in:
Alexey Shekhirin
2024-08-21 21:58:49 +01:00
committed by GitHub
parent 302ce7f482
commit 3da119b1ac
30 changed files with 236 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -8743,6 +8743,7 @@ dependencies = [
name = "reth-testing-utils"
version = "1.0.5"
dependencies = [
"alloy-eips",
"alloy-genesis",
"rand 0.8.5",
"reth-primitives",

2
crates/blockchain-tree/src/block_buffer.rs
View File

@ -191,7 +191,7 @@ mod tests {
/// Create random block with specified number and parent hash.
fn create_block<R: Rng>(rng: &mut R, number: u64, parent: BlockHash) -> SealedBlockWithSenders {
let block = random_block(rng, number, Some(parent), None, None);
let block = random_block(rng, number, Some(parent), None, None, None);
block.seal_with_senders().unwrap()
}

43
crates/consensus/beacon/src/engine/mod.rs
View File

@ -2229,8 +2229,8 @@ mod tests {
})]))
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
let (_static_dir, static_dir_path) = create_test_static_files_dir();
insert_blocks(
@ -2288,8 +2288,8 @@ mod tests {
.disable_blockchain_tree_sync()
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
let (_static_dir, static_dir_path) = create_test_static_files_dir();
@ -2304,7 +2304,7 @@ mod tests {
let mut engine_rx = spawn_consensus_engine(consensus_engine);
let next_head = random_block(&mut rng, 2, Some(block1.hash()), None, Some(0));
let next_head = random_block(&mut rng, 2, Some(block1.hash()), None, Some(0), None);
let next_forkchoice_state = ForkchoiceState {
head_block_hash: next_head.hash(),
finalized_block_hash: block1.hash(),
@ -2356,8 +2356,8 @@ mod tests {
.disable_blockchain_tree_sync()
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
let (_static_dir, static_dir_path) = create_test_static_files_dir();
@ -2403,16 +2403,16 @@ mod tests {
]))
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let mut block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let mut block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
block1.header.set_difficulty(U256::from(1));
// a second pre-merge block
let mut block2 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let mut block2 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
block2.header.set_difficulty(U256::from(1));
// a transition block
let mut block3 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let mut block3 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
block3.header.set_difficulty(U256::from(1));
let (_static_dir, static_dir_path) = create_test_static_files_dir();
@ -2460,8 +2460,8 @@ mod tests {
]))
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
let (_temp_dir, temp_dir_path) = create_test_static_files_dir();
@ -2524,7 +2524,7 @@ mod tests {
// Send new payload
let res = env
.send_new_payload(
block_to_payload_v1(random_block(&mut rng, 0, None, None, Some(0))),
block_to_payload_v1(random_block(&mut rng, 0, None, None, Some(0), None)),
None,
)
.await;
@ -2535,7 +2535,7 @@ mod tests {
// Send new payload
let res = env
.send_new_payload(
block_to_payload_v1(random_block(&mut rng, 1, None, None, Some(0))),
block_to_payload_v1(random_block(&mut rng, 1, None, None, Some(0), None)),
None,
)
.await;
@ -2564,9 +2564,9 @@ mod tests {
})]))
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0));
let block2 = random_block(&mut rng, 2, Some(block1.hash()), None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let block1 = random_block(&mut rng, 1, Some(genesis.hash()), None, Some(0), None);
let block2 = random_block(&mut rng, 2, Some(block1.hash()), None, Some(0), None);
let (_static_dir, static_dir_path) = create_test_static_files_dir();
insert_blocks(
@ -2634,7 +2634,8 @@ mod tests {
let genesis =
SealedBlock { header: chain_spec.sealed_genesis_header(), ..Default::default() };
let block1 = random_block(&mut rng, 1, Some(chain_spec.genesis_hash()), None, Some(0));
let block1 =
random_block(&mut rng, 1, Some(chain_spec.genesis_hash()), None, Some(0), None);
// TODO: add transactions that transfer from the alloc accounts, generating the new
// block tx and state root
@ -2684,7 +2685,7 @@ mod tests {
})]))
.build();
let genesis = random_block(&mut rng, 0, None, None, Some(0));
let genesis = random_block(&mut rng, 0, None, None, Some(0), None);
let (_static_dir, static_dir_path) = create_test_static_files_dir();
@ -2713,7 +2714,7 @@ mod tests {
// Send new payload
let parent = rng.gen();
let block = random_block(&mut rng, 2, Some(parent), None, Some(0));
let block = random_block(&mut rng, 2, Some(parent), None, Some(0), None);
let res = env.send_new_payload(block_to_payload_v1(block), None).await;
let expected_result = PayloadStatus::from_status(PayloadStatusEnum::Syncing);
assert_matches!(res, Ok(result) => assert_eq!(result, expected_result));

2
crates/net/downloaders/src/bodies/bodies.rs
View File

@ -652,7 +652,7 @@ mod tests {
// Generate some random blocks
let db = create_test_rw_db();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=199, B256::ZERO, 1..2);
let blocks = random_block_range(&mut rng, 0..=199, B256::ZERO, 1..2, None);
let headers = blocks.iter().map(|block| block.header.clone()).collect::<Vec<_>>();
let bodies = blocks

2
crates/net/downloaders/src/test_utils/mod.rs
View File

@ -21,7 +21,7 @@ pub(crate) fn generate_bodies(
range: RangeInclusive<u64>,
) -> (Vec<SealedHeader>, HashMap<B256, BlockBody>) {
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, range, B256::ZERO, 0..2);
let blocks = random_block_range(&mut rng, range, B256::ZERO, 0..2, None);
let headers = blocks.iter().map(|block| block.header.clone()).collect();
let bodies = blocks

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

@ -99,7 +99,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3);
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let mut receipts = Vec::new();

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

@ -105,7 +105,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 1..=100, B256::ZERO, 2..3);
let blocks = random_block_range(&mut rng, 1..=100, B256::ZERO, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let transactions = blocks.iter().flat_map(|block| &block.body).collect::<Vec<_>>();

2
crates/prune/prune/src/segments/user/account_history.rs
View File

@ -151,7 +151,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 1..=5000, B256::ZERO, 0..1);
let blocks = random_block_range(&mut rng, 1..=5000, B256::ZERO, 0..1, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let accounts = random_eoa_accounts(&mut rng, 2).into_iter().collect::<BTreeMap<_, _>>();

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

@ -242,9 +242,9 @@ mod tests {
let tip = 20000;
let blocks = [
random_block_range(&mut rng, 0..=100, B256::ZERO, 1..5),
random_block_range(&mut rng, (100 + 1)..=(tip - 100), B256::ZERO, 0..1),
random_block_range(&mut rng, (tip - 100 + 1)..=tip, B256::ZERO, 1..5),
random_block_range(&mut rng, 0..=100, B256::ZERO, 1..5, None),
random_block_range(&mut rng, (100 + 1)..=(tip - 100), B256::ZERO, 0..1, None),
random_block_range(&mut rng, (tip - 100 + 1)..=tip, B256::ZERO, 1..5, None),
]
.concat();
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");

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

@ -101,7 +101,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3);
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let mut transaction_senders = Vec::new();

2
crates/prune/prune/src/segments/user/storage_history.rs
View File

@ -157,7 +157,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=5000, B256::ZERO, 0..1);
let blocks = random_block_range(&mut rng, 0..=5000, B256::ZERO, 0..1, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let accounts = random_eoa_accounts(&mut rng, 2).into_iter().collect::<BTreeMap<_, _>>();

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

@ -130,7 +130,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3);
let blocks = random_block_range(&mut rng, 1..=10, B256::ZERO, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
let mut tx_hash_numbers = Vec::new();

24
crates/rpc/rpc-engine-api/src/engine_api.rs
View File

@ -1030,8 +1030,13 @@ mod tests {
let (handle, api) = setup_engine_api();
let (start, count) = (1, 10);
let blocks =
random_block_range(&mut rng, start..=start + count - 1, B256::default(), 0..2);
let blocks = random_block_range(
&mut rng,
start..=start + count - 1,
B256::default(),
0..2,
None,
);
handle.provider.extend_blocks(blocks.iter().cloned().map(|b| (b.hash(), b.unseal())));
let expected = blocks
@ -1050,8 +1055,13 @@ mod tests {
let (handle, api) = setup_engine_api();
let (start, count) = (1, 100);
let blocks =
random_block_range(&mut rng, start..=start + count - 1, B256::default(), 0..2);
let blocks = random_block_range(
&mut rng,
start..=start + count - 1,
B256::default(),
0..2,
None,
);
// Insert only blocks in ranges 1-25 and 50-75
let first_missing_range = 26..=50;
@ -1143,9 +1153,9 @@ mod tests {
let terminal_block_number = 1000;
let consensus_terminal_block =
random_block(&mut rng, terminal_block_number, None, None, None);
random_block(&mut rng, terminal_block_number, None, None, None, None);
let execution_terminal_block =
random_block(&mut rng, terminal_block_number, None, None, None);
random_block(&mut rng, terminal_block_number, None, None, None, None);
let transition_config = TransitionConfiguration {
terminal_total_difficulty: handle
@ -1187,7 +1197,7 @@ mod tests {
let terminal_block_number = 1000;
let terminal_block =
random_block(&mut generators::rng(), terminal_block_number, None, None, None);
random_block(&mut generators::rng(), terminal_block_number, None, None, None, None);
let transition_config = TransitionConfiguration {
terminal_total_difficulty: handle

4
crates/rpc/rpc-engine-api/tests/it/payload.rs
View File

@ -32,7 +32,7 @@ fn transform_block<F: FnOnce(Block) -> Block>(src: SealedBlock, f: F) -> Executi
#[test]
fn payload_body_roundtrip() {
let mut rng = generators::rng();
for block in random_block_range(&mut rng, 0..=99, B256::default(), 0..2) {
for block in random_block_range(&mut rng, 0..=99, B256::default(), 0..2, None) {
let unsealed = block.clone().unseal();
let payload_body: ExecutionPayloadBodyV1 = convert_to_payload_body_v1(unsealed);
@ -53,7 +53,7 @@ fn payload_body_roundtrip() {
fn payload_validation() {
let mut rng = generators::rng();
let parent = rng.gen();
let block = random_block(&mut rng, 100, Some(parent), Some(3), Some(0));
let block = random_block(&mut rng, 100, Some(parent), Some(3), Some(0), None);
// Valid extra data
let block_with_valid_extra_data = transform_block(block.clone(), |mut b| {

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

@ -116,7 +116,7 @@ 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);
let mut blocks = random_block_range(&mut rng, 0..=num_blocks, B256::ZERO, txs_range, None);
let (transitions, start_state) = random_changeset_range(
&mut rng,

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

@ -719,7 +719,7 @@ 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);
let blocks = random_block_range(&mut rng, 0..=end, GENESIS_HASH, 0..2, None);
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

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

@ -72,7 +72,7 @@ impl AccountHashingStage {
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, opts.blocks.clone(), B256::ZERO, opts.txs);
let blocks = random_block_range(&mut rng, opts.blocks.clone(), B256::ZERO, opts.txs, None);
for block in blocks {
provider.insert_historical_block(block.try_seal_with_senders().unwrap()).unwrap();

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

@ -342,7 +342,7 @@ 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);
let blocks = random_block_range(&mut rng, stage_progress..=end, B256::ZERO, 0..3, None);
self.db.insert_headers(blocks.iter().map(|block| &block.header))?;

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

@ -538,7 +538,7 @@ mod tests {
.into_iter()
.collect::<BTreeMap<_, _>>();
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3);
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3, None);
let (changesets, _) = random_changeset_range(
&mut rng,

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

@ -560,7 +560,7 @@ mod tests {
.into_iter()
.collect::<BTreeMap<_, _>>();
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3);
let blocks = random_block_range(&mut rng, start..=end, B256::ZERO, 0..3, None);
let (changesets, _) = random_changeset_range(
&mut rng,

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

@ -501,6 +501,7 @@ mod tests {
0..=stage_progress - 1,
B256::ZERO,
0..1,
None,
));
self.db.insert_blocks(preblocks.iter(), StorageKind::Static)?;
}
@ -520,6 +521,7 @@ mod tests {
preblocks.last().map(|b| b.hash()),
Some(0),
None,
None,
);
let mut header = header.unseal();
@ -534,7 +536,7 @@ 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));
blocks.extend(random_block_range(&mut rng, start..=end, head_hash, 0..3, None));
let last_block = blocks.last().cloned().unwrap();
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;

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

@ -94,7 +94,7 @@ 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));
let nblock = random_block(&mut rng, block_number, Some(head), Some(0), Some(0), None);
head = nblock.hash();
provider_rw.insert_historical_block(nblock.try_seal_with_senders().unwrap()).unwrap();
}
@ -253,7 +253,7 @@ 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);
let blocks = random_block_range(&mut rng, 0..=tip, genesis_hash, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Static)?;
let mut receipts = Vec::new();

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

@ -202,6 +202,7 @@ mod tests {
input.checkpoint().block_number..=input.target(),
B256::ZERO,
1..3,
None,
);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
self.db.insert_transaction_senders(

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

@ -325,6 +325,7 @@ mod tests {
None,
Some((number == non_empty_block_number) as u8),
None,
None,
)
})
.collect::<Vec<_>>();
@ -363,8 +364,13 @@ mod tests {
let (stage_progress, previous_stage) = (1000, 1100); // input exceeds threshold
// Manually seed once with full input range
let seed =
random_block_range(&mut rng, stage_progress + 1..=previous_stage, B256::ZERO, 0..4); // set tx count range high enough to hit the threshold
let seed = random_block_range(
&mut rng,
stage_progress + 1..=previous_stage,
B256::ZERO,
0..4,
None,
); // set tx count range high enough to hit the threshold
runner
.db
.insert_blocks(seed.iter(), StorageKind::Static)
@ -434,7 +440,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10);
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10, None);
db.insert_blocks(blocks.iter(), StorageKind::Static).expect("insert blocks");
let max_pruned_block = 30;
@ -547,7 +553,7 @@ 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);
let blocks = random_block_range(&mut rng, stage_progress..=end, B256::ZERO, 0..2, None);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
Ok(blocks)
}

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

@ -276,6 +276,7 @@ mod tests {
None,
Some((number == non_empty_block_number) as u8),
None,
None,
)
})
.collect::<Vec<_>>();
@ -318,8 +319,13 @@ mod tests {
};
// Seed only once with full input range
let seed =
random_block_range(&mut rng, stage_progress + 1..=previous_stage, B256::ZERO, 0..2);
let seed = random_block_range(
&mut rng,
stage_progress + 1..=previous_stage,
B256::ZERO,
0..2,
None,
);
runner
.db
.insert_blocks(seed.iter(), StorageKind::Static)
@ -353,7 +359,7 @@ mod tests {
let db = TestStageDB::default();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10);
let blocks = random_block_range(&mut rng, 0..=100, B256::ZERO, 0..10, None);
db.insert_blocks(blocks.iter(), StorageKind::Static).expect("insert blocks");
let max_pruned_block = 30;
@ -479,7 +485,8 @@ mod tests {
let end = input.target();
let mut rng = generators::rng();
let blocks = random_block_range(&mut rng, stage_progress + 1..=end, B256::ZERO, 0..2);
let blocks =
random_block_range(&mut rng, stage_progress + 1..=end, B256::ZERO, 0..2, None);
self.db.insert_blocks(blocks.iter(), StorageKind::Static)?;
Ok(blocks)
}

2
crates/static-file/static-file/src/static_file_producer.rs
View File

@ -279,7 +279,7 @@ mod tests {
let mut rng = generators::rng();
let db = TestStageDB::default();
let blocks = random_block_range(&mut rng, 0..=3, B256::ZERO, 2..3);
let blocks = random_block_range(&mut rng, 0..=3, B256::ZERO, 2..3, None);
db.insert_blocks(blocks.iter(), StorageKind::Database(None)).expect("insert blocks");
// Unwind headers from static_files and manually insert them into the database, so we're
// able to check that static_file_producer works

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

@ -1487,20 +1487,22 @@ where
#[cfg(test)]
mod tests {
use std::sync::Arc;
use std::{ops::Range, sync::Arc};
use itertools::Itertools;
use rand::Rng;
use reth_chain_state::{ExecutedBlock, NewCanonicalChain};
use reth_chainspec::ChainSpecProvider;
use reth_chainspec::{
ChainSpec, ChainSpecBuilder, ChainSpecProvider, EthereumHardfork, MAINNET,
};
use reth_db::{models::AccountBeforeTx, test_utils::TempDatabase, DatabaseEnv};
use reth_execution_types::ExecutionOutcome;
use reth_primitives::{
BlockHashOrNumber, BlockNumberOrTag, Header, Receipt, SealedBlock, StaticFileSegment, B256,
BlockHashOrNumber, BlockNumberOrTag, Receipt, SealedBlock, StaticFileSegment, B256,
};
use reth_storage_api::{
BlockHashReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
ChangeSetReader, HeaderProvider, ReceiptProviderIdExt,
ChangeSetReader, HeaderProvider, ReceiptProviderIdExt, RequestsProvider,
};
use reth_testing_utils::generators::{
self, random_block, random_block_range, random_changeset_range, random_eoa_accounts,
@ -1509,8 +1511,9 @@ mod tests {
use revm::db::BundleState;
use crate::{
providers::BlockchainProvider2, test_utils::create_test_provider_factory, BlockWriter,
CanonChainTracker, StaticFileWriter,
providers::BlockchainProvider2,
test_utils::{create_test_provider_factory, create_test_provider_factory_with_chain_spec},
BlockWriter, CanonChainTracker, StaticFileWriter,
};
const TEST_BLOCKS_COUNT: usize = 5;
@ -1519,18 +1522,21 @@ mod tests {
rng: &mut impl Rng,
database_blocks: usize,
in_memory_blocks: usize,
requests_count: Option<Range<u8>>,
) -> (Vec<SealedBlock>, Vec<SealedBlock>) {
let block_range = (database_blocks + in_memory_blocks - 1) as u64;
let blocks = random_block_range(rng, 0..=block_range, B256::ZERO, 0..1);
let blocks = random_block_range(rng, 0..=block_range, B256::ZERO, 0..1, requests_count);
let (database_blocks, in_memory_blocks) = blocks.split_at(database_blocks);
(database_blocks.to_vec(), in_memory_blocks.to_vec())
}
#[allow(clippy::type_complexity)]
fn provider_with_random_blocks(
#[allow(clippy::type_complexity, clippy::too_many_arguments)]
fn provider_with_chain_spec_and_random_blocks(
rng: &mut impl Rng,
chain_spec: Arc<ChainSpec>,
database_blocks: usize,
in_memory_blocks: usize,
requests_count: Option<Range<u8>>,
) -> eyre::Result<(
BlockchainProvider2<Arc<TempDatabase<DatabaseEnv>>>,
Vec<SealedBlock>,
@ -1538,7 +1544,7 @@ mod tests {
Vec<Vec<Receipt>>,
)> {
let (database_blocks, in_memory_blocks) =
random_blocks(rng, database_blocks, in_memory_blocks);
random_blocks(rng, database_blocks, in_memory_blocks, requests_count);
let receipts: Vec<Vec<_>> = database_blocks
.iter()
.chain(in_memory_blocks.iter())
@ -1546,7 +1552,7 @@ mod tests {
.map(|tx| tx.map(|tx| random_receipt(rng, tx, Some(2))).collect())
.collect();
let factory = create_test_provider_factory();
let factory = create_test_provider_factory_with_chain_spec(chain_spec);
let provider_rw = factory.provider_rw()?;
// Insert blocks and receipts into the database
@ -1604,6 +1610,27 @@ mod tests {
Ok((provider, database_blocks.to_vec(), in_memory_blocks.to_vec(), receipts))
}
#[allow(clippy::type_complexity)]
fn provider_with_random_blocks(
rng: &mut impl Rng,
database_blocks: usize,
in_memory_blocks: usize,
requests_count: Option<Range<u8>>,
) -> eyre::Result<(
BlockchainProvider2<Arc<TempDatabase<DatabaseEnv>>>,
Vec<SealedBlock>,
Vec<SealedBlock>,
Vec<Vec<Receipt>>,
)> {
provider_with_chain_spec_and_random_blocks(
rng,
MAINNET.clone(),
database_blocks,
in_memory_blocks,
requests_count,
)
}
#[test]
fn test_block_reader_find_block_by_hash() -> eyre::Result<()> {
// Initialize random number generator and provider factory
@ -1611,7 +1638,7 @@ mod tests {
let factory = create_test_provider_factory();
// Generate 10 random blocks and split into database and in-memory blocks
let blocks = random_block_range(&mut rng, 0..=10, B256::ZERO, 0..1);
let blocks = random_block_range(&mut rng, 0..=10, B256::ZERO, 0..1, None);
let (database_blocks, in_memory_blocks) = blocks.split_at(5);
// Insert first 5 blocks into the database
@ -1705,7 +1732,7 @@ mod tests {
let factory = create_test_provider_factory();
// Generate 10 random blocks and split into database and in-memory blocks
let blocks = random_block_range(&mut rng, 0..=10, B256::ZERO, 0..1);
let blocks = random_block_range(&mut rng, 0..=10, B256::ZERO, 0..1, None);
let (database_blocks, in_memory_blocks) = blocks.split_at(5);
// Insert first 5 blocks into the database
@ -1770,11 +1797,11 @@ mod tests {
fn test_block_reader_pending_block() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, _, _, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
// Generate a random block
let mut rng = generators::rng();
let block = random_block(&mut rng, 0, Some(B256::ZERO), None, None);
let block = random_block(&mut rng, 0, Some(B256::ZERO), None, None, None);
// Set the block as pending
provider.canonical_in_memory_state.set_pending_block(ExecutedBlock {
@ -1803,50 +1830,17 @@ mod tests {
#[test]
fn test_block_reader_ommers() -> eyre::Result<()> {
// Initialize random number generator and provider factory
let mut rng = generators::rng();
let factory = create_test_provider_factory();
// Generate 10 random blocks and split into database and in-memory blocks
let blocks = random_block_range(&mut rng, 0..=10, B256::ZERO, 0..1);
let (database_blocks, in_memory_blocks) = blocks.split_at(5);
// Take the first in memory block and add 7 ommers to it
let first_in_mem_block = SealedBlock {
ommers: vec![Header::default(); 7],
..in_memory_blocks.first().unwrap().clone()
};
// Insert first 5 blocks into the database
let provider_rw = factory.provider_rw()?;
for block in database_blocks {
provider_rw.insert_historical_block(
block.clone().seal_with_senders().expect("failed to seal block with senders"),
)?;
}
provider_rw.commit()?;
// Create a new provider
let provider = BlockchainProvider2::new(factory.clone())?;
let mut rng = generators::rng();
let (provider, _, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
// Insert first block into the in-memory state
let in_memory_block_senders =
first_in_mem_block.senders().expect("failed to recover senders");
let chain = NewCanonicalChain::Commit {
new: vec![ExecutedBlock::new(
Arc::new(first_in_mem_block.clone()),
Arc::new(in_memory_block_senders),
Default::default(),
Default::default(),
Default::default(),
)],
};
provider.canonical_in_memory_state.update_chain(chain);
let first_in_mem_block = in_memory_blocks.first().unwrap();
// If the block is after the Merge, we should have an empty ommers list
assert_eq!(
provider.ommers(
(factory.chain_spec().paris_block_and_final_difficulty.unwrap().0 + 2).into()
(provider.chain_spec().paris_block_and_final_difficulty.unwrap().0 + 2).into()
)?,
Some(vec![])
);
@ -1858,7 +1852,7 @@ mod tests {
);
assert_eq!(
provider.ommers(first_in_mem_block.hash().into())?,
Some(first_in_mem_block.ommers)
Some(first_in_mem_block.ommers.clone())
);
// A random hash should return None as the block number is not found
@ -1871,7 +1865,7 @@ mod tests {
fn test_block_hash_reader() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -1895,7 +1889,7 @@ mod tests {
fn test_header_provider() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -1960,7 +1954,7 @@ mod tests {
fn test_block_num_reader() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
assert_eq!(provider.best_block_number()?, in_memory_blocks.last().unwrap().number);
assert_eq!(provider.last_block_number()?, database_blocks.last().unwrap().number);
@ -1974,10 +1968,10 @@ mod tests {
}
#[test]
fn test_block_reader_id_ext_block_by_id() {
fn test_block_reader_id_ext_block_by_id() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -2000,13 +1994,15 @@ mod tests {
provider.block_by_id(block_hash.into()).unwrap(),
Some(in_memory_block.unseal())
);
Ok(())
}
#[test]
fn test_block_reader_id_ext_header_by_number_or_tag() {
fn test_block_reader_id_ext_header_by_number_or_tag() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
@ -2051,13 +2047,15 @@ mod tests {
provider.sealed_header_by_number_or_tag(BlockNumberOrTag::Finalized).unwrap(),
Some(finalized_block.header)
);
Ok(())
}
#[test]
fn test_block_reader_id_ext_header_by_id() {
fn test_block_reader_id_ext_header_by_id() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -2103,13 +2101,15 @@ mod tests {
provider.sealed_header_by_id(block_hash.into()).unwrap(),
Some(in_memory_block.header)
);
Ok(())
}
#[test]
fn test_block_reader_id_ext_ommers_by_id() {
fn test_block_reader_id_ext_ommers_by_id() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -2137,13 +2137,15 @@ mod tests {
provider.ommers_by_id(block_hash.into()).unwrap().unwrap_or_default(),
in_memory_block.ommers
);
Ok(())
}
#[test]
fn test_receipt_provider_id_ext_receipts_by_block_id() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, receipts) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
@ -2179,7 +2181,7 @@ mod tests {
fn test_receipt_provider_id_ext_receipts_by_block_number_or_tag() -> eyre::Result<()> {
let mut rng = generators::rng();
let (provider, database_blocks, in_memory_blocks, receipts) =
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
provider_with_random_blocks(&mut rng, TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT, None)?;
let database_block = database_blocks.first().unwrap().clone();
@ -2211,7 +2213,10 @@ mod tests {
#[test]
fn test_changeset_reader() -> eyre::Result<()> {
let mut rng = generators::rng();
let (database_blocks, in_memory_blocks) = random_blocks(&mut rng, TEST_BLOCKS_COUNT, 1);
let (database_blocks, in_memory_blocks) =
random_blocks(&mut rng, TEST_BLOCKS_COUNT, 1, None);
let first_database_block = database_blocks.first().map(|block| block.number).unwrap();
let last_database_block = database_blocks.last().map(|block| block.number).unwrap();
let first_in_memory_block = in_memory_blocks.first().map(|block| block.number).unwrap();
@ -2320,4 +2325,35 @@ mod tests {
Ok(())
}
#[test]
fn test_requests_provider() -> eyre::Result<()> {
let mut rng = generators::rng();
let chain_spec = Arc::new(ChainSpecBuilder::mainnet().prague_activated().build());
let (provider, database_blocks, in_memory_blocks, _) =
provider_with_chain_spec_and_random_blocks(
&mut rng,
chain_spec.clone(),
TEST_BLOCKS_COUNT,
TEST_BLOCKS_COUNT,
Some(1..2),
)?;
let database_block = database_blocks.first().unwrap().clone();
let in_memory_block = in_memory_blocks.last().unwrap().clone();
let prague_timestamp =
chain_spec.hardforks.fork(EthereumHardfork::Prague).as_timestamp().unwrap();
assert_eq!(
provider.requests_by_block(database_block.number.into(), prague_timestamp,)?,
database_block.requests.clone()
);
assert_eq!(
provider.requests_by_block(in_memory_block.number.into(), prague_timestamp,)?,
in_memory_block.requests.clone()
);
Ok(())
}
}

2
crates/storage/provider/src/providers/database/mod.rs
View File

@ -711,7 +711,7 @@ mod tests {
let factory = create_test_provider_factory();
let mut rng = generators::rng();
let block = random_block(&mut rng, 0, None, Some(3), None);
let block = random_block(&mut rng, 0, None, Some(3), None, None);
let tx_ranges: Vec<RangeInclusive<TxNumber>> = vec![0..=0, 1..=1, 2..=2, 0..=1, 1..=2];
for range in tx_ranges {

3
testing/testing-utils/Cargo.toml
View File

@ -14,7 +14,8 @@ workspace = true
[dependencies]
reth-primitives = { workspace = true, features = ["secp256k1"] }
alloy-eips.workspace = true
alloy-genesis.workspace = true
secp256k1 = { workspace = true, features = ["rand"] }
rand.workspace = true
secp256k1 = { workspace = true, features = ["rand"] }

44
testing/testing-utils/src/generators.rs
View File

@ -1,12 +1,16 @@
//! Generators for different data structures like block headers, block bodies and ranges of those.
use alloy_eips::{
eip6110::DepositRequest, eip7002::WithdrawalRequest, eip7251::ConsolidationRequest,
};
pub use rand::Rng;
use rand::{
distributions::uniform::SampleRange, rngs::StdRng, seq::SliceRandom, thread_rng, SeedableRng,
};
use reth_primitives::{
proofs, sign_message, Account, Address, BlockNumber, Bytes, Header, Log, Receipt, SealedBlock,
SealedHeader, StorageEntry, Transaction, TransactionSigned, TxKind, TxLegacy, B256, U256,
proofs, sign_message, Account, Address, BlockNumber, Bytes, Header, Log, Receipt, Request,
Requests, SealedBlock, SealedHeader, StorageEntry, Transaction, TransactionSigned, TxKind,
TxLegacy, B256, U256,
};
use secp256k1::{Keypair, Secp256k1};
use std::{
@ -133,6 +137,7 @@ pub fn random_block<R: Rng>(
parent: Option<B256>,
tx_count: Option<u8>,
ommers_count: Option<u8>,
requests_count: Option<u8>,
) -> SealedBlock {
// Generate transactions
let tx_count = tx_count.unwrap_or_else(|| rng.gen::<u8>());
@ -149,6 +154,10 @@ pub fn random_block<R: Rng>(
let transactions_root = proofs::calculate_transaction_root(&transactions);
let ommers_hash = proofs::calculate_ommers_root(&ommers);
let requests =
requests_count.map(|count| (0..count).map(|_| random_request(rng)).collect::<Vec<_>>());
let requests_root = requests.as_ref().map(|requests| proofs::calculate_requests_root(requests));
SealedBlock {
header: Header {
parent_hash: parent.unwrap_or_default(),
@ -158,13 +167,14 @@ pub fn random_block<R: Rng>(
transactions_root,
ommers_hash,
base_fee_per_gas: Some(rng.gen()),
requests_root,
..Default::default()
}
.seal_slow(),
body: transactions,
ommers,
withdrawals: None,
requests: None,
requests: requests.map(Requests),
}
}
@ -179,17 +189,20 @@ pub fn random_block_range<R: Rng>(
block_numbers: RangeInclusive<BlockNumber>,
head: B256,
tx_count: Range<u8>,
requests_count: Option<Range<u8>>,
) -> Vec<SealedBlock> {
let mut blocks =
Vec::with_capacity(block_numbers.end().saturating_sub(*block_numbers.start()) as usize);
for idx in block_numbers {
let tx_count = tx_count.clone().sample_single(rng);
let requests_count = requests_count.clone().map(|r| r.sample_single(rng));
blocks.push(random_block(
rng,
idx,
Some(blocks.last().map(|block: &SealedBlock| block.header.hash()).unwrap_or(head)),
Some(tx_count),
None,
requests_count,
));
}
blocks
@ -383,6 +396,31 @@ pub fn random_log<R: Rng>(rng: &mut R, address: Option<Address>, topics_count: O
)
}
/// Generate random request
pub fn random_request<R: Rng>(rng: &mut R) -> Request {
let request_type = rng.gen_range(0..3);
match request_type {
0 => Request::DepositRequest(DepositRequest {
pubkey: rng.gen(),
withdrawal_credentials: rng.gen(),
amount: rng.gen(),
signature: rng.gen(),
index: rng.gen(),
}),
1 => Request::WithdrawalRequest(WithdrawalRequest {
source_address: rng.gen(),
validator_pubkey: rng.gen(),
amount: rng.gen(),
}),
2 => Request::ConsolidationRequest(ConsolidationRequest {
source_address: rng.gen(),
source_pubkey: rng.gen(),
target_pubkey: rng.gen(),
}),
_ => panic!("invalid request type"),
}
}
#[cfg(test)]
mod tests {
use super::*;