github/reth
1
1
Fork 0
mirror of https://github.com/paradigmxyz/reth.git synced 2026-01-08 23:08:19 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore: alloy 0.14 (#15635)

Browse Source 
Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
This commit is contained in:
Yash Atreya
2025-04-11 11:58:57 +05:30
committed by GitHub
parent 2563e93d95
commit 58fe204ff2
126 changed files with 968 additions and 868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

747
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

118
Cargo.toml
View File

@@ -438,69 +438,70 @@ reth-ress-protocol = { path = "crates/ress/protocol" }
reth-ress-provider = { path = "crates/ress/provider" }
# revm
revm = { version = "21.0.0", default-features = false }
revm-bytecode = { version = "2.0.0", default-features = false }
revm-database = { version = "2.0.0", default-features = false }
revm-state = { version = "2.0.0", default-features = false }
revm-primitives = { version = "17.0.0", default-features = false }
revm-interpreter = { version = "17.0.0", default-features = false }
revm-inspector = { version = "2.0.0", default-features = false }
revm-context = { version = "2.0.0", default-features = false }
revm-context-interface = { version = "2.0.0", default-features = false }
revm-database-interface = { version = "2.0.0", default-features = false }
op-revm = { version = "2.0.0", default-features = false }
revm-inspectors = "0.18.0"
revm = { version = "22.0.0", default-features = false }
revm-bytecode = { version = "3.0.0", default-features = false }
revm-database = { version = "3.0.0", default-features = false }
revm-state = { version = "3.0.0", default-features = false }
revm-primitives = { version = "18.0.0", default-features = false }
revm-interpreter = { version = "18.0.0", default-features = false }
revm-inspector = { version = "3.0.0", default-features = false }
revm-context = { version = "3.0.0", default-features = false }
revm-context-interface = { version = "3.0.0", default-features = false }
revm-database-interface = { version = "3.0.0", default-features = false }
op-revm = { version = "3.0.0", default-features = false }
revm-inspectors = "0.19.0"
# eth
alloy-chains = { version = "0.1.68", default-features = false }
alloy-dyn-abi = "0.8.25"
alloy-eip2124 = { version = "0.1.0", default-features = false }
alloy-evm = { version = "0.3.2", default-features = false }
alloy-primitives = { version = "0.8.25", default-features = false, features = ["map-foldhash"] }
alloy-chains = { version = "0.2.0", default-features = false }
alloy-dyn-abi = "1.0.0"
alloy-eip2124 = { version = "0.2.0", default-features = false }
alloy-evm = { version = "0.4.0", default-features = false }
alloy-primitives = { version = "1.0.0", default-features = false, features = ["map-foldhash"] }
alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] }
alloy-sol-types = { version = "0.8.25", default-features = false }
alloy-trie = { version = "0.7.9", default-features = false }
alloy-sol-macro = "1.0.0"
alloy-sol-types = { version = "1.0.0", default-features = false }
alloy-trie = { version = "0.8.0", default-features = false }
alloy-hardforks = "0.1.4"
alloy-hardforks = "0.2.0"
alloy-consensus = { version = "0.13.0", default-features = false }
alloy-contract = { version = "0.13.0", default-features = false }
alloy-eips = { version = "0.13.0", default-features = false }
alloy-genesis = { version = "0.13.0", default-features = false }
alloy-json-rpc = { version = "0.13.0", default-features = false }
alloy-network = { version = "0.13.0", default-features = false }
alloy-network-primitives = { version = "0.13.0", default-features = false }
alloy-node-bindings = { version = "0.13.0", default-features = false }
alloy-provider = { version = "0.13.0", features = ["reqwest"], default-features = false }
alloy-pubsub = { version = "0.13.0", default-features = false }
alloy-rpc-client = { version = "0.13.0", default-features = false }
alloy-rpc-types = { version = "0.13.0", features = ["eth"], default-features = false }
alloy-rpc-types-admin = { version = "0.13.0", default-features = false }
alloy-rpc-types-anvil = { version = "0.13.0", default-features = false }
alloy-rpc-types-beacon = { version = "0.13.0", default-features = false }
alloy-rpc-types-debug = { version = "0.13.0", default-features = false }
alloy-rpc-types-engine = { version = "0.13.0", default-features = false }
alloy-rpc-types-eth = { version = "0.13.0", default-features = false }
alloy-rpc-types-mev = { version = "0.13.0", default-features = false }
alloy-rpc-types-trace = { version = "0.13.0", default-features = false }
alloy-rpc-types-txpool = { version = "0.13.0", default-features = false }
alloy-serde = { version = "0.13.0", default-features = false }
alloy-signer = { version = "0.13.0", default-features = false }
alloy-signer-local = { version = "0.13.0", default-features = false }
alloy-transport = { version = "0.13.0" }
alloy-transport-http = { version = "0.13.0", features = ["reqwest-rustls-tls"], default-features = false }
alloy-transport-ipc = { version = "0.13.0", default-features = false }
alloy-transport-ws = { version = "0.13.0", default-features = false }
alloy-consensus = { version = "0.14.0", default-features = false }
alloy-contract = { version = "0.14.0", default-features = false }
alloy-eips = { version = "0.14.0", default-features = false }
alloy-genesis = { version = "0.14.0", default-features = false }
alloy-json-rpc = { version = "0.14.0", default-features = false }
alloy-network = { version = "0.14.0", default-features = false }
alloy-network-primitives = { version = "0.14.0", default-features = false }
alloy-node-bindings = { version = "0.14.0", default-features = false }
alloy-provider = { version = "0.14.0", features = ["reqwest"], default-features = false }
alloy-pubsub = { version = "0.14.0", default-features = false }
alloy-rpc-client = { version = "0.14.0", default-features = false }
alloy-rpc-types = { version = "0.14.0", features = ["eth"], default-features = false }
alloy-rpc-types-admin = { version = "0.14.0", default-features = false }
alloy-rpc-types-anvil = { version = "0.14.0", default-features = false }
alloy-rpc-types-beacon = { version = "0.14.0", default-features = false }
alloy-rpc-types-debug = { version = "0.14.0", default-features = false }
alloy-rpc-types-engine = { version = "0.14.0", default-features = false }
alloy-rpc-types-eth = { version = "0.14.0", default-features = false }
alloy-rpc-types-mev = { version = "0.14.0", default-features = false }
alloy-rpc-types-trace = { version = "0.14.0", default-features = false }
alloy-rpc-types-txpool = { version = "0.14.0", default-features = false }
alloy-serde = { version = "0.14.0", default-features = false }
alloy-signer = { version = "0.14.0", default-features = false }
alloy-signer-local = { version = "0.14.0", default-features = false }
alloy-transport = { version = "0.14.0" }
alloy-transport-http = { version = "0.14.0", features = ["reqwest-rustls-tls"], default-features = false }
alloy-transport-ipc = { version = "0.14.0", default-features = false }
alloy-transport-ws = { version = "0.14.0", default-features = false }
# op
alloy-op-evm = { version = "0.3.2", default-features = false }
alloy-op-hardforks = "0.1.2"
op-alloy-rpc-types = { version = "0.12.2", default-features = false }
op-alloy-rpc-types-engine = { version = "0.12.2", default-features = false }
op-alloy-network = { version = "0.12.2", default-features = false }
op-alloy-consensus = { version = "0.12.2", default-features = false }
op-alloy-rpc-jsonrpsee = { version = "0.12.2", default-features = false }
op-alloy-flz = { version = "0.12.0", default-features = false }
alloy-op-evm = { version = "0.4.0", default-features = false }
alloy-op-hardforks = "0.2.0"
op-alloy-rpc-types = { version = "0.13.0", default-features = false }
op-alloy-rpc-types-engine = { version = "0.13.0", default-features = false }
op-alloy-network = { version = "0.13.0", default-features = false }
op-alloy-consensus = { version = "0.13.0", default-features = false }
op-alloy-rpc-jsonrpsee = { version = "0.13.0", default-features = false }
op-alloy-flz = { version = "0.13.0", default-features = false }
# misc
aquamarine = "0.6"
@@ -530,7 +531,7 @@ nybbles = { version = "0.3.0", default-features = false }
once_cell = { version = "1.19", default-features = false, features = ["critical-section"] }
parking_lot = "0.12"
paste = "1.0"
rand = "0.8.5"
rand = "0.9"
rayon = "1.7"
rustc-hash = { version = "2.0", default-features = false }
schnellru = "0.2"
@@ -603,6 +604,8 @@ proptest-arbitrary-interop = "0.1.0"
enr = { version = "0.13", default-features = false }
k256 = { version = "0.13", default-features = false, features = ["ecdsa"] }
secp256k1 = { version = "0.30", default-features = false, features = ["global-context", "recovery"] }
# rand 8 for secp256k1
rand_08 = { package = "rand", version = "0.8" }
# for eip-4844
c-kzg = "2.1.0"
@@ -639,7 +642,6 @@ snmalloc-rs = { version = "0.3.7", features = ["build_cc"] }
crunchy = "=0.2.2"
aes = "0.8.1"
ahash = "0.8"
alloy-sol-macro = "0.8.9"
anyhow = "1.0"
bindgen = { version = "0.70", default-features = false }
block-padding = "0.3.2"

8
crates/chain-state/src/in_memory.rs
View File

@@ -1114,7 +1114,7 @@ mod tests {
#[test]
fn test_in_memory_state_impl_state_by_hash() {
let mut state_by_hash = HashMap::default();
let number = rand::thread_rng().gen::<u64>();
let number = rand::rng().random::<u64>();
let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
let state = Arc::new(create_mock_state(&mut test_block_builder, number, B256::random()));
state_by_hash.insert(state.hash(), state.clone());
@@ -1130,7 +1130,7 @@ mod tests {
let mut state_by_hash = HashMap::default();
let mut hash_by_number = BTreeMap::new();
let number = rand::thread_rng().gen::<u64>();
let number = rand::rng().random::<u64>();
let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
let state = Arc::new(create_mock_state(&mut test_block_builder, number, B256::random()));
let hash = state.hash();
@@ -1167,7 +1167,7 @@ mod tests {
#[test]
fn test_in_memory_state_impl_pending_state() {
let pending_number = rand::thread_rng().gen::<u64>();
let pending_number = rand::rng().random::<u64>();
let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
let pending_state =
create_mock_state(&mut test_block_builder, pending_number, B256::random());
@@ -1193,7 +1193,7 @@ mod tests {
#[test]
fn test_state() {
let number = rand::thread_rng().gen::<u64>();
let number = rand::rng().random::<u64>();
let mut test_block_builder: TestBlockBuilder = TestBlockBuilder::default();
let block = test_block_builder.get_executed_block_with_number(number, B256::random());

8
crates/chain-state/src/test_utils.rs
View File

@@ -13,7 +13,7 @@ use alloy_primitives::{Address, BlockNumber, B256, U256};
use alloy_signer::SignerSync;
use alloy_signer_local::PrivateKeySigner;
use core::marker::PhantomData;
use rand::{thread_rng, Rng};
use rand::Rng;
use reth_chainspec::{ChainSpec, EthereumHardfork, MIN_TRANSACTION_GAS};
use reth_ethereum_primitives::{
Block, BlockBody, EthPrimitives, Receipt, Transaction, TransactionSigned,
@@ -96,7 +96,7 @@ impl<N: NodePrimitives> TestBlockBuilder<N> {
number: BlockNumber,
parent_hash: B256,
) -> RecoveredBlock<reth_ethereum_primitives::Block> {
let mut rng = thread_rng();
let mut rng = rand::rng();
let mock_tx = |nonce: u64| -> Recovered<_> {
let tx = Transaction::Eip1559(TxEip1559 {
@@ -114,7 +114,7 @@ impl<N: NodePrimitives> TestBlockBuilder<N> {
TransactionSigned::new_unhashed(tx, signature).with_signer(self.signer)
};
let num_txs = rng.gen_range(0..5);
let num_txs = rng.random_range(0..5);
let signer_balance_decrease = Self::single_tx_cost() * U256::from(num_txs);
let transactions: Vec<Recovered<_>> = (0..num_txs)
.map(|_| {
@@ -232,7 +232,7 @@ impl<N: NodePrimitives> TestBlockBuilder<N> {
receipts: Vec<Vec<Receipt>>,
parent_hash: B256,
) -> ExecutedBlockWithTrieUpdates {
let number = rand::thread_rng().gen::<u64>();
let number = rand::rng().random::<u64>();
self.get_executed_block(number, receipts, parent_hash)
}

9
crates/cli/commands/src/test_vectors/compact.rs
View File

@@ -1,5 +1,5 @@
use alloy_eips::eip4895::Withdrawals;
use alloy_primitives::{hex, private::getrandom::getrandom, PrimitiveSignature, TxKind};
use alloy_primitives::{hex, Signature, TxKind, B256};
use arbitrary::Arbitrary;
use eyre::{Context, Result};
use proptest::{
@@ -128,7 +128,7 @@ compact_types!(
],
// These types require an extra identifier which is usually stored elsewhere (eg. parent type).
identifier: [
PrimitiveSignature,
Signature,
Transaction,
TxType,
TxKind
@@ -147,13 +147,12 @@ pub fn read_vectors() -> Result<()> {
/// Generates a vector of type `T` to a file.
pub fn generate_vectors_with(gen: &[fn(&mut TestRunner) -> eyre::Result<()>]) -> Result<()> {
// Prepare random seed for test (same method as used by proptest)
let mut seed = [0u8; 32];
getrandom(&mut seed)?;
let seed = B256::random();
println!("Seed for compact test vectors: {:?}", hex::encode_prefixed(seed));
// Start the runner with the seed
let config = ProptestConfig::default();
let rng = TestRng::from_seed(config.rng_algorithm, &seed);
let rng = TestRng::from_seed(config.rng_algorithm, &seed.0);
let mut runner = TestRunner::new_with_rng(config, rng);
fs::create_dir_all(VECTORS_FOLDER)?;

7
crates/cli/commands/src/test_vectors/tables.rs
View File

@@ -1,5 +1,5 @@
use alloy_consensus::Header;
use alloy_primitives::{hex, private::getrandom::getrandom};
use alloy_primitives::{hex, B256};
use arbitrary::Arbitrary;
use eyre::Result;
use proptest::{
@@ -23,13 +23,12 @@ const PER_TABLE: usize = 1000;
/// Generates test vectors for specified `tables`. If list is empty, then generate for all tables.
pub fn generate_vectors(mut tables: Vec<String>) -> Result<()> {
// Prepare random seed for test (same method as used by proptest)
let mut seed = [0u8; 32];
getrandom(&mut seed)?;
let seed = B256::random();
println!("Seed for table test vectors: {:?}", hex::encode_prefixed(seed));
// Start the runner with the seed
let config = ProptestConfig::default();
let rng = TestRng::from_seed(config.rng_algorithm, &seed);
let rng = TestRng::from_seed(config.rng_algorithm, &seed.0);
let mut runner = TestRunner::new_with_rng(config, rng);
fs::create_dir_all(VECTORS_FOLDER)?;

5
crates/cli/util/Cargo.toml
View File

@@ -21,13 +21,16 @@ alloy-eips.workspace = true
# misc
cfg-if.workspace = true
eyre.workspace = true
rand.workspace = true
secp256k1 = { workspace = true, features = ["rand"] }
rand_08.workspace = true
thiserror.workspace = true
serde.workspace = true
tracy-client = { workspace = true, optional = true, features = ["demangle"] }
[dev-dependencies]
rand.workspace = true
[target.'cfg(unix)'.dependencies]
tikv-jemallocator = { workspace = true, optional = true }
snmalloc-rs = { workspace = true, optional = true }

2
crates/cli/util/src/load_secret_key.rs
View File

@@ -8,7 +8,7 @@ use thiserror::Error;
/// Convenience function to create a new random [`SecretKey`]
pub fn rng_secret_key() -> SecretKey {
SecretKey::new(&mut rand::thread_rng())
SecretKey::new(&mut rand_08::thread_rng())
}
/// Errors returned by loading a [`SecretKey`], including IO errors.

2
crates/cli/util/src/parsers.rs
View File

@@ -107,7 +107,7 @@ mod tests {
#[test]
fn parse_socket_address_random() {
let port: u16 = rand::thread_rng().gen();
let port: u16 = rand::rng().random();
for value in [format!("localhost:{port}"), format!(":{port}"), port.to_string()] {
let socket_addr = parse_socket_address(&value)

8
crates/consensus/common/src/validation.rs
View File

@@ -348,14 +348,14 @@ mod tests {
use super::*;
use alloy_consensus::{BlockBody, Header, TxEip4844};
use alloy_eips::eip4895::Withdrawals;
use alloy_primitives::{Address, Bytes, PrimitiveSignature as Signature, U256};
use alloy_primitives::{Address, Bytes, Signature, U256};
use rand::Rng;
use reth_chainspec::ChainSpecBuilder;
use reth_ethereum_primitives::{Transaction, TransactionSigned};
use reth_primitives_traits::proofs;
fn mock_blob_tx(nonce: u64, num_blobs: usize) -> TransactionSigned {
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
let request = Transaction::Eip4844(TxEip4844 {
chain_id: 1u64,
nonce,
@@ -367,7 +367,9 @@ mod tests {
value: U256::from(3_u64),
input: Bytes::from(vec![1, 2]),
access_list: Default::default(),
blob_versioned_hashes: std::iter::repeat_with(|| rng.gen()).take(num_blobs).collect(),
blob_versioned_hashes: std::iter::repeat_with(|| rng.random())
.take(num_blobs)
.collect(),
});
let signature = Signature::new(U256::default(), U256::default(), true);

3
crates/engine/invalid-block-hooks/src/witness.rs
View File

@@ -125,7 +125,8 @@ where
let state = state_provider.witness(Default::default(), hashed_state.clone())?;
// Write the witness to the output directory.
let response = ExecutionWitness { state, codes, keys: state_preimages };
let response =
ExecutionWitness { state, codes, keys: state_preimages, ..Default::default() };
let re_executed_witness_path = self.save_file(
format!("{}_{}.witness.re_executed.json", block.number(), block.hash()),
&response,

1
crates/engine/tree/Cargo.toml
View File

@@ -98,6 +98,7 @@ criterion.workspace = true
crossbeam-channel.workspace = true
proptest.workspace = true
rand.workspace = true
rand_08.workspace = true
[[bench]]
name = "channel_perf"

2
crates/engine/tree/benches/channel_perf.rs
View File

@@ -5,7 +5,7 @@
use alloy_primitives::{B256, U256};
use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
use proptest::test_runner::TestRunner;
use rand::Rng;
use rand_08::Rng;
use revm_primitives::{Address, HashMap};
use revm_state::{Account, AccountInfo, AccountStatus, EvmState, EvmStorage, EvmStorageSlot};
use std::{hint::black_box, thread};

9
crates/engine/tree/benches/state_root_task.rs
View File

@@ -8,7 +8,7 @@ use alloy_evm::block::StateChangeSource;
use alloy_primitives::{Address, B256};
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use proptest::test_runner::TestRunner;
use rand::Rng;
use rand_08::Rng;
use reth_chain_state::EthPrimitives;
use reth_chainspec::ChainSpec;
use reth_db_common::init::init_genesis;
@@ -41,7 +41,12 @@ struct BenchParams {
fn create_bench_state_updates(params: &BenchParams) -> Vec<EvmState> {
let mut runner = TestRunner::deterministic();
let mut rng = runner.rng().clone();
let all_addresses: Vec<Address> = (0..params.num_accounts).map(|_| rng.gen()).collect();
let all_addresses: Vec<Address> = (0..params.num_accounts)
.map(|_| {
// TODO: rand08
Address::random()
})
.collect();
let mut updates = Vec::new();
for _ in 0..params.updates_per_account {

32
crates/engine/tree/src/tree/block_buffer.rs
View File

@@ -236,7 +236,7 @@ mod tests {
#[test]
fn simple_insertion() {
let mut rng = generators::rng();
let parent = rng.gen();
let parent = rng.random();
let block1 = create_block(&mut rng, 10, parent);
let mut buffer = BlockBuffer::new(3);
@@ -249,11 +249,11 @@ mod tests {
fn take_entire_chain_of_children() {
let mut rng = generators::rng();
let main_parent_hash = rng.gen();
let main_parent_hash = rng.random();
let block1 = create_block(&mut rng, 10, main_parent_hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 12, block2.hash());
let parent4 = rng.gen();
let parent4 = rng.random();
let block4 = create_block(&mut rng, 14, parent4);
let mut buffer = BlockBuffer::new(5);
@@ -282,7 +282,7 @@ mod tests {
fn take_all_multi_level_children() {
let mut rng = generators::rng();
let main_parent_hash = rng.gen();
let main_parent_hash = rng.random();
let block1 = create_block(&mut rng, 10, main_parent_hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 11, block1.hash());
@@ -316,7 +316,7 @@ mod tests {
fn take_block_with_children() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 11, block1.hash());
@@ -350,11 +350,11 @@ mod tests {
fn remove_chain_of_children() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 12, block2.hash());
let parent4 = rng.gen();
let parent4 = rng.random();
let block4 = create_block(&mut rng, 14, parent4);
let mut buffer = BlockBuffer::new(5);
@@ -373,7 +373,7 @@ mod tests {
fn remove_all_multi_level_children() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 11, block1.hash());
@@ -395,16 +395,16 @@ mod tests {
fn remove_multi_chains() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block1a = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block2a = create_block(&mut rng, 11, block1.hash());
let random_parent1 = rng.gen();
let random_parent1 = rng.random();
let random_block1 = create_block(&mut rng, 10, random_parent1);
let random_parent2 = rng.gen();
let random_parent2 = rng.random();
let random_block2 = create_block(&mut rng, 11, random_parent2);
let random_parent3 = rng.gen();
let random_parent3 = rng.random();
let random_block3 = create_block(&mut rng, 12, random_parent3);
let mut buffer = BlockBuffer::new(10);
@@ -439,11 +439,11 @@ mod tests {
fn evict_with_gap() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 12, block2.hash());
let parent4 = rng.gen();
let parent4 = rng.random();
let block4 = create_block(&mut rng, 13, parent4);
let mut buffer = BlockBuffer::new(3);
@@ -476,11 +476,11 @@ mod tests {
fn simple_eviction() {
let mut rng = generators::rng();
let main_parent = BlockNumHash::new(9, rng.gen());
let main_parent = BlockNumHash::new(9, rng.random());
let block1 = create_block(&mut rng, 10, main_parent.hash);
let block2 = create_block(&mut rng, 11, block1.hash());
let block3 = create_block(&mut rng, 12, block2.hash());
let parent4 = rng.gen();
let parent4 = rng.random();
let block4 = create_block(&mut rng, 13, parent4);
let mut buffer = BlockBuffer::new(3);

6
crates/engine/tree/src/tree/cached_state.rs
View File

@@ -639,10 +639,10 @@ mod tests {
fn measure_storage_cache_overhead() {
let (base_overhead, cache) = measure_allocation(|| AccountStorageCache::new(1000));
println!("Base AccountStorageCache overhead: {} bytes", base_overhead);
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
let key = StorageKey::random();
let value = StorageValue::from(rng.gen::<u128>());
let value = StorageValue::from(rng.random::<u128>());
let (first_slot, _) = measure_allocation(|| {
cache.insert_storage(key, Some(value));
});
@@ -652,7 +652,7 @@ mod tests {
let (test_slots, _) = measure_allocation(|| {
for _ in 0..TOTAL_SLOTS {
let key = StorageKey::random();
let value = StorageValue::from(rng.gen::<u128>());
let value = StorageValue::from(rng.random::<u128>());
cache.insert_storage(key, Some(value));
}
});

22
crates/engine/tree/src/tree/payload_processor/mod.rs
View File

@@ -426,6 +426,7 @@ mod tests {
StateProviderBuilder, TreeConfig,
};
use alloy_evm::block::StateChangeSource;
use rand::Rng;
use reth_chainspec::ChainSpec;
use reth_db_common::init::init_genesis;
use reth_ethereum_primitives::EthPrimitives;
@@ -437,38 +438,41 @@ mod tests {
test_utils::create_test_provider_factory_with_chain_spec,
ChainSpecProvider, HashingWriter,
};
use reth_testing_utils::generators::{self, Rng};
use reth_testing_utils::generators;
use reth_trie::{test_utils::state_root, HashedPostState, TrieInput};
use revm_primitives::{Address, HashMap, B256, KECCAK_EMPTY, U256};
use revm_state::{AccountInfo, AccountStatus, EvmState, EvmStorageSlot};
fn create_mock_state_updates(num_accounts: usize, updates_per_account: usize) -> Vec<EvmState> {
let mut rng = generators::rng();
let all_addresses: Vec<Address> = (0..num_accounts).map(|_| rng.gen()).collect();
let all_addresses: Vec<Address> = (0..num_accounts).map(|_| rng.random()).collect();
let mut updates = Vec::new();
for _ in 0..updates_per_account {
let num_accounts_in_update = rng.gen_range(1..=num_accounts);
let num_accounts_in_update = rng.random_range(1..=num_accounts);
let mut state_update = EvmState::default();
let selected_addresses = &all_addresses[0..num_accounts_in_update];
for &address in selected_addresses {
let mut storage = HashMap::default();
if rng.gen_bool(0.7) {
for _ in 0..rng.gen_range(1..10) {
let slot = U256::from(rng.gen::<u64>());
if rng.random_bool(0.7) {
for _ in 0..rng.random_range(1..10) {
let slot = U256::from(rng.random::<u64>());
storage.insert(
slot,
EvmStorageSlot::new_changed(U256::ZERO, U256::from(rng.gen::<u64>())),
EvmStorageSlot::new_changed(
U256::ZERO,
U256::from(rng.random::<u64>()),
),
);
}
}
let account = revm_state::Account {
info: AccountInfo {
balance: U256::from(rng.gen::<u64>()),
nonce: rng.gen::<u64>(),
balance: U256::from(rng.random::<u64>()),
nonce: rng.random::<u64>(),
code_hash: KECCAK_EMPTY,
code: Some(Default::default()),
},

8
crates/ethereum/evm/src/execute.rs
View File

@@ -49,7 +49,6 @@ mod tests {
state::{AccountInfo, Bytecode, EvmState},
Database,
};
use secp256k1::{Keypair, Secp256k1};
use std::sync::mpsc;
fn create_database_with_beacon_root_contract() -> CacheDB<EmptyDB> {
@@ -679,8 +678,7 @@ mod tests {
let mut db = create_database_with_withdrawal_requests_contract();
let secp = Secp256k1::new();
let sender_key_pair = Keypair::new(&secp, &mut generators::rng());
let sender_key_pair = generators::generate_key(&mut generators::rng());
let sender_address = public_key_to_address(sender_key_pair.public_key());
db.insert_account_info(
@@ -748,10 +746,8 @@ mod tests {
// Create a state provider with the withdrawal requests contract pre-deployed
let mut db = create_database_with_withdrawal_requests_contract();
// Initialize Secp256k1 for key pair generation
let secp = Secp256k1::new();
// Generate a new key pair for the sender
let sender_key_pair = Keypair::new(&secp, &mut generators::rng());
let sender_key_pair = generators::generate_key(&mut generators::rng());
// Get the sender's address from the public key
let sender_address = public_key_to_address(sender_key_pair.public_key());

6
crates/ethereum/node/tests/e2e/p2p.rs
View File

@@ -53,7 +53,7 @@ async fn can_sync() -> eyre::Result<()> {
async fn e2e_test_send_transactions() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
let seed: [u8; 32] = rand::thread_rng().gen();
let seed: [u8; 32] = rand::rng().random();
let mut rng = StdRng::from_seed(seed);
println!("Seed: {:?}", seed);
@@ -89,7 +89,7 @@ async fn e2e_test_send_transactions() -> eyre::Result<()> {
async fn test_long_reorg() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
let seed: [u8; 32] = rand::thread_rng().gen();
let seed: [u8; 32] = rand::rng().random();
let mut rng = StdRng::from_seed(seed);
println!("Seed: {:?}", seed);
@@ -139,7 +139,7 @@ async fn test_long_reorg() -> eyre::Result<()> {
async fn test_reorg_through_backfill() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
let seed: [u8; 32] = rand::thread_rng().gen();
let seed: [u8; 32] = rand::rng().random();
let mut rng = StdRng::from_seed(seed);
println!("Seed: {:?}", seed);

11
crates/ethereum/node/tests/e2e/rpc.rs
View File

@@ -33,7 +33,7 @@ alloy_sol_types::sol! {
async fn test_fee_history() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
let seed: [u8; 32] = rand::thread_rng().gen();
let seed: [u8; 32] = rand::rng().random();
let mut rng = StdRng::from_seed(seed);
println!("Seed: {:?}", seed);
@@ -71,8 +71,9 @@ async fn test_fee_history() -> eyre::Result<()> {
assert_eq!(block.header.base_fee_per_gas.unwrap(), expected_first_base_fee as u64);
for _ in 0..100 {
let _ =
GasWaster::deploy_builder(&provider, U256::from(rng.gen_range(0..1000))).send().await?;
let _ = GasWaster::deploy_builder(&provider, U256::from(rng.random_range(0..1000)))
.send()
.await?;
node.advance_block().await?;
}
@@ -80,8 +81,8 @@ async fn test_fee_history() -> eyre::Result<()> {
let latest_block = provider.get_block_number().await?;
for _ in 0..100 {
let latest_block = rng.gen_range(0..=latest_block);
let block_count = rng.gen_range(1..=(latest_block + 1));
let latest_block = rng.random_range(0..=latest_block);
let block_count = rng.random_range(1..=(latest_block + 1));
let fee_history = provider.get_fee_history(block_count, latest_block.into(), &[]).await?;

14
crates/ethereum/node/tests/e2e/utils.rs
View File

@@ -9,7 +9,7 @@ use alloy_provider::{
use alloy_rpc_types_engine::PayloadAttributes;
use alloy_rpc_types_eth::TransactionRequest;
use alloy_signer::SignerSync;
use rand::{seq::SliceRandom, Rng};
use rand::{seq::IndexedRandom, Rng};
use reth_e2e_test_utils::{wallet::Wallet, NodeHelperType, TmpDB};
use reth_ethereum_engine_primitives::EthPayloadBuilderAttributes;
use reth_ethereum_primitives::TxType;
@@ -47,12 +47,12 @@ where
let mut call_destinations = signers.iter().map(|s| s.address()).collect::<Vec<_>>();
for _ in 0..num_blocks {
let tx_count = rng.gen_range(1..20);
let tx_count = rng.random_range(1..20);
let mut pending = vec![];
for _ in 0..tx_count {
let signer = signers.choose(rng).unwrap();
let tx_type = TxType::try_from(rng.gen_range(0..=4) as u64).unwrap();
let tx_type = TxType::try_from(rng.random_range(0..=4) as u64).unwrap();
let nonce = provider
.get_transaction_count(signer.address())
@@ -63,12 +63,12 @@ where
TransactionRequest::default().with_from(signer.address()).with_nonce(nonce);
let should_create =
rng.gen::<bool>() && tx_type != TxType::Eip4844 && tx_type != TxType::Eip7702;
rng.random::<bool>() && tx_type != TxType::Eip4844 && tx_type != TxType::Eip7702;
if should_create {
tx = tx.into_create().with_input(dummy_bytecode.clone());
} else {
tx = tx.with_to(*call_destinations.choose(rng).unwrap()).with_input(
(0..rng.gen_range(0..10000)).map(|_| rng.gen()).collect::<Vec<u8>>(),
(0..rng.random_range(0..10000)).map(|_| rng.random()).collect::<Vec<u8>>(),
);
}
@@ -76,11 +76,11 @@ where
tx = tx.with_gas_price(provider.get_gas_price().await?);
}
if rng.gen::<bool>() || tx_type == TxType::Eip2930 {
if rng.random::<bool>() || tx_type == TxType::Eip2930 {
tx = tx.with_access_list(
vec![AccessListItem {
address: *call_destinations.choose(rng).unwrap(),
storage_keys: (0..rng.gen_range(0..100)).map(|_| rng.gen()).collect(),
storage_keys: (0..rng.random_range(0..100)).map(|_| rng.random()).collect(),
}]
.into(),
);

8
crates/ethereum/primitives/Cargo.toml
View File

@@ -31,7 +31,7 @@ revm-context.workspace = true
arbitrary = { workspace = true, optional = true, features = ["derive"] }
derive_more.workspace = true
modular-bitfield = { workspace = true, optional = true }
rand = { workspace = true, optional = true }
rand_08 = { workspace = true, optional = true }
secp256k1 = { workspace = true, optional = true, features = ["rand"] }
serde = { workspace = true, optional = true }
serde_with = { workspace = true, optional = true }
@@ -41,6 +41,7 @@ arbitrary.workspace = true
bincode.workspace = true
proptest.workspace = true
proptest-arbitrary-interop.workspace = true
rand_08.workspace = true
rand.workspace = true
reth-codecs = { workspace = true, features = ["test-utils"] }
reth-testing-utils.workspace = true
@@ -79,7 +80,7 @@ reth-codec = [
]
arbitrary = [
"dep:arbitrary",
"dep:rand",
"dep:rand_08",
"dep:secp256k1",
"alloy-consensus/arbitrary",
"alloy-primitives/arbitrary",
@@ -100,9 +101,10 @@ serde = [
"alloy-eips/serde",
"alloy-primitives/serde",
"alloy-rpc-types-eth?/serde",
"rand?/serde",
"rand_08?/serde",
"reth-codecs?/serde",
"reth-primitives-traits/serde",
"revm-context/serde",
"secp256k1?/serde",
"rand/serde",
]

2
crates/ethereum/primitives/src/receipt.rs
View File

@@ -310,7 +310,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(bytes.as_mut_slice());
rand::rng().fill(bytes.as_mut_slice());
let data = Data {
reseipt: Receipt::arbitrary(&mut arbitrary::Unstructured::new(&bytes)).unwrap(),
};

10
crates/ethereum/primitives/src/transaction.rs
View File

@@ -13,8 +13,7 @@ use alloy_eips::{
};
use alloy_evm::{FromRecoveredTx, FromTxWithEncoded};
use alloy_primitives::{
bytes::BufMut, keccak256, Address, Bytes, ChainId, PrimitiveSignature as Signature, TxHash,
TxKind, B256, U256,
bytes::BufMut, keccak256, Address, Bytes, ChainId, Signature, TxHash, TxKind, B256, U256,
};
use alloy_rlp::{Decodable, Encodable};
use core::hash::{Hash, Hasher};
@@ -621,7 +620,7 @@ impl<'a> arbitrary::Arbitrary<'a> for TransactionSigned {
let mut transaction = Transaction::arbitrary(u)?;
let secp = secp256k1::Secp256k1::new();
let key_pair = secp256k1::Keypair::new(&secp, &mut rand::thread_rng());
let key_pair = secp256k1::Keypair::new(&secp, &mut rand_08::thread_rng());
let signature = reth_primitives_traits::crypto::secp256k1::sign_message(
B256::from_slice(&key_pair.secret_bytes()[..]),
transaction.signature_hash(),
@@ -968,7 +967,7 @@ pub(super) mod serde_bincode_compat {
transaction::serde_bincode_compat::{TxEip1559, TxEip2930, TxEip7702, TxLegacy},
TxEip4844,
};
use alloy_primitives::{PrimitiveSignature as Signature, TxHash};
use alloy_primitives::{Signature, TxHash};
use reth_primitives_traits::{serde_bincode_compat::SerdeBincodeCompat, SignedTransaction};
/// Bincode-compatible [`super::Transaction`] serde implementation.
@@ -1103,8 +1102,7 @@ mod tests {
eip7702::constants::SECP256K1N_HALF,
};
use alloy_primitives::{
address, b256, bytes, hex, Address, Bytes, PrimitiveSignature as Signature, TxKind, B256,
U256,
address, b256, bytes, hex, Address, Bytes, Signature, TxKind, B256, U256,
};
use alloy_rlp::{Decodable, Encodable, Error as RlpError};
use proptest::proptest;

2
crates/evm/execution-types/src/chain.rs
View File

@@ -680,7 +680,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(bytes.as_mut_slice());
rand::rng().fill(bytes.as_mut_slice());
let data = Data {
chain: Chain::new(
vec![RecoveredBlock::arbitrary(&mut arbitrary::Unstructured::new(&bytes))

2
crates/evm/execution-types/src/execution_outcome.rs
View File

@@ -534,7 +534,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(bytes.as_mut_slice());
rand::rng().fill(bytes.as_mut_slice());
let data = Data {
data: ExecutionOutcome {
bundle: Default::default(),

5
crates/exex/exex/src/backfill/job.rs
View File

@@ -254,14 +254,13 @@ mod tests {
providers::BlockchainProvider, test_utils::create_test_provider_factory_with_chain_spec,
};
use reth_testing_utils::generators;
use secp256k1::Keypair;
#[test]
fn test_backfill() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
// Create a key pair for the sender
let key_pair = Keypair::new_global(&mut generators::rng());
let key_pair = generators::generate_key(&mut generators::rng());
let address = public_key_to_address(key_pair.public_key());
let chain_spec = chain_spec(address);
@@ -297,7 +296,7 @@ mod tests {
reth_tracing::init_test_tracing();
// Create a key pair for the sender
let key_pair = Keypair::new_global(&mut generators::rng());
let key_pair = generators::generate_key(&mut generators::rng());
let address = public_key_to_address(key_pair.public_key());
let chain_spec = chain_spec(address);

5
crates/exex/exex/src/backfill/stream.rs
View File

@@ -251,14 +251,13 @@ mod tests {
};
use reth_stages_api::ExecutionStageThresholds;
use reth_testing_utils::generators;
use secp256k1::Keypair;
#[tokio::test]
async fn test_single_blocks() -> eyre::Result<()> {
reth_tracing::init_test_tracing();
// Create a key pair for the sender
let key_pair = Keypair::new_global(&mut generators::rng());
let key_pair = generators::generate_key(&mut generators::rng());
let address = public_key_to_address(key_pair.public_key());
let chain_spec = chain_spec(address);
@@ -295,7 +294,7 @@ mod tests {
reth_tracing::init_test_tracing();
// Create a key pair for the sender
let key_pair = Keypair::new_global(&mut generators::rng());
let key_pair = generators::generate_key(&mut generators::rng());
let address = public_key_to_address(key_pair.public_key());
let chain_spec = chain_spec(address);

2
crates/exex/exex/src/manager.rs
View File

@@ -1372,7 +1372,7 @@ mod tests {
// Send a `FinishedHeight` event with a non-canonical block
events_tx
.send(ExExEvent::FinishedHeight((rng.gen::<u64>(), rng.gen::<B256>()).into()))
.send(ExExEvent::FinishedHeight((rng.random::<u64>(), rng.random::<B256>()).into()))
.unwrap();
finalized_headers_tx.send(Some(block.clone_sealed_header()))?;

1
crates/exex/test-utils/Cargo.toml
View File

@@ -42,6 +42,5 @@ tokio.workspace = true
## misc
eyre.workspace = true
rand.workspace = true
tempfile.workspace = true
thiserror.workspace = true

4
crates/exex/test-utils/src/lib.rs
View File

@@ -28,7 +28,7 @@ use reth_ethereum_primitives::{EthPrimitives, TransactionSigned};
use reth_evm::test_utils::MockExecutorProvider;
use reth_execution_types::Chain;
use reth_exex::{ExExContext, ExExEvent, ExExNotification, ExExNotifications, Wal};
use reth_network::{config::SecretKey, NetworkConfigBuilder, NetworkManager};
use reth_network::{config::rng_secret_key, NetworkConfigBuilder, NetworkManager};
use reth_node_api::{
FullNodeTypes, FullNodeTypesAdapter, NodePrimitives, NodeTypes, NodeTypesWithDBAdapter,
};
@@ -272,7 +272,7 @@ pub async fn test_exex_context_with_chain_spec(
let provider = BlockchainProvider::new(provider_factory.clone())?;
let network_manager = NetworkManager::new(
NetworkConfigBuilder::new(SecretKey::new(&mut rand::thread_rng()))
NetworkConfigBuilder::new(rng_secret_key())
.with_unused_discovery_port()
.with_unused_listener_port()
.build(provider_factory.clone()),

2
crates/exex/types/src/notification.rs
View File

@@ -199,7 +199,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(bytes.as_mut_slice());
rand::rng().fill(bytes.as_mut_slice());
let data = Data {
notification: ExExNotification::ChainReorged {
old: Arc::new(Chain::new(

8
crates/net/discv4/Cargo.toml
View File

@@ -34,7 +34,7 @@ schnellru.workspace = true
tracing.workspace = true
thiserror.workspace = true
parking_lot.workspace = true
rand = { workspace = true, optional = true }
rand_08 = { workspace = true, optional = true }
generic-array.workspace = true
serde = { workspace = true, optional = true }
itertools.workspace = true
@@ -42,7 +42,7 @@ itertools.workspace = true
[dev-dependencies]
secp256k1 = { workspace = true, features = ["rand"] }
assert_matches.workspace = true
rand.workspace = true
rand_08.workspace = true
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
reth-tracing.workspace = true
@@ -55,8 +55,8 @@ serde = [
"enr/serde",
"generic-array/serde",
"parking_lot/serde",
"rand?/serde",
"rand_08?/serde",
"secp256k1/serde",
"reth-ethereum-forks/serde",
]
test-utils = ["dep:rand"]
test-utils = ["dep:rand_08"]

22
crates/net/discv4/src/lib.rs
View File

@@ -214,15 +214,13 @@ impl Discv4 {
///
/// ```
/// # use std::io;
/// use rand::thread_rng;
/// use reth_discv4::{Discv4, Discv4Config};
/// use reth_network_peers::{pk2id, NodeRecord, PeerId};
/// use secp256k1::SECP256K1;
/// use std::{net::SocketAddr, str::FromStr};
/// # async fn t() -> io::Result<()> {
/// // generate a (random) keypair
/// let mut rng = thread_rng();
/// let (secret_key, pk) = SECP256K1.generate_keypair(&mut rng);
/// let (secret_key, pk) = SECP256K1.generate_keypair(&mut rand_08::thread_rng());
/// let id = pk2id(&pk);
///
/// let socket = SocketAddr::from_str("0.0.0.0:0").unwrap();
@@ -2399,7 +2397,7 @@ mod tests {
use crate::test_utils::{create_discv4, create_discv4_with_config, rng_endpoint, rng_record};
use alloy_primitives::hex;
use alloy_rlp::{Decodable, Encodable};
use rand::{thread_rng, Rng};
use rand_08::Rng;
use reth_ethereum_forks::{EnrForkIdEntry, ForkHash};
use reth_network_peers::mainnet_nodes;
use std::future::poll_fn;
@@ -2534,7 +2532,7 @@ mod tests {
#[tokio::test]
async fn test_mapped_ipv4() {
reth_tracing::init_test_tracing();
let mut rng = thread_rng();
let mut rng = rand_08::thread_rng();
let config = Discv4Config::builder().build();
let (_discv4, mut service) = create_discv4_with_config(config).await;
@@ -2549,8 +2547,8 @@ mod tests {
enr_sq: Some(rng.gen()),
};
let id = PeerId::random_with(&mut rng);
service.on_ping(ping, addr, id, rng.gen());
let id = PeerId::random();
service.on_ping(ping, addr, id, B256::random());
let key = kad_key(id);
match service.kbuckets.entry(&key) {
@@ -2566,7 +2564,7 @@ mod tests {
#[tokio::test]
async fn test_respect_ping_expiration() {
reth_tracing::init_test_tracing();
let mut rng = thread_rng();
let mut rng = rand_08::thread_rng();
let config = Discv4Config::builder().build();
let (_discv4, mut service) = create_discv4_with_config(config).await;
@@ -2581,8 +2579,8 @@ mod tests {
enr_sq: Some(rng.gen()),
};
let id = PeerId::random_with(&mut rng);
service.on_ping(ping, addr, id, rng.gen());
let id = PeerId::random();
service.on_ping(ping, addr, id, B256::random());
let key = kad_key(id);
match service.kbuckets.entry(&key) {
@@ -2979,7 +2977,7 @@ mod tests {
#[test]
fn test_insert() {
let local_node_record = rng_record(&mut rand::thread_rng());
let local_node_record = rng_record(&mut rand_08::thread_rng());
let mut kbuckets: KBucketsTable<NodeKey, NodeEntry> = KBucketsTable::new(
NodeKey::from(&local_node_record).into(),
Duration::from_secs(60),
@@ -2988,7 +2986,7 @@ mod tests {
None,
);
let new_record = rng_record(&mut rand::thread_rng());
let new_record = rng_record(&mut rand_08::thread_rng());
let key = kad_key(new_record.id);
match kbuckets.entry(&key) {
kbucket::Entry::Absent(entry) => {

32
crates/net/discv4/src/proto.rs
View File

@@ -594,12 +594,12 @@ mod tests {
use alloy_primitives::hex;
use assert_matches::assert_matches;
use enr::EnrPublicKey;
use rand::{thread_rng, Rng, RngCore};
use rand_08::{thread_rng as rng, Rng, RngCore};
use reth_ethereum_forks::ForkHash;
#[test]
fn test_endpoint_ipv_v4() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 4];
rng.fill_bytes(&mut ip);
@@ -616,7 +616,7 @@ mod tests {
#[test]
fn test_endpoint_ipv_64() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
@@ -633,7 +633,7 @@ mod tests {
#[test]
fn test_ping_message() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
@@ -651,7 +651,7 @@ mod tests {
#[test]
fn test_ping_message_with_enr() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
@@ -669,13 +669,13 @@ mod tests {
#[test]
fn test_pong_message() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
let msg = Pong {
to: rng_endpoint(&mut rng),
echo: rng.gen(),
echo: B256::random(),
expire: rng.gen(),
enr_sq: None,
};
@@ -687,13 +687,13 @@ mod tests {
#[test]
fn test_pong_message_with_enr() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
let msg = Pong {
to: rng_endpoint(&mut rng),
echo: rng.gen(),
echo: B256::random(),
expire: rng.gen(),
enr_sq: Some(rng.gen()),
};
@@ -705,7 +705,7 @@ mod tests {
#[test]
fn test_hash_mismatch() {
let mut rng = thread_rng();
let mut rng = rng();
let msg = rng_message(&mut rng);
let (secret_key, _) = SECP256K1.generate_keypair(&mut rng);
let (buf, _) = msg.encode(&secret_key);
@@ -722,7 +722,7 @@ mod tests {
#[test]
fn neighbours_max_ipv4() {
let mut rng = thread_rng();
let mut rng = rng();
let msg = Message::Neighbours(Neighbours {
nodes: std::iter::repeat_with(|| rng_ipv4_record(&mut rng)).take(16).collect(),
expire: rng.gen(),
@@ -736,7 +736,7 @@ mod tests {
#[test]
fn neighbours_max_nodes() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..1000 {
let msg = Message::Neighbours(Neighbours {
nodes: std::iter::repeat_with(|| rng_ipv6_record(&mut rng))
@@ -764,7 +764,7 @@ mod tests {
#[test]
fn test_encode_decode_message() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let msg = rng_message(&mut rng);
let (secret_key, pk) = SECP256K1.generate_keypair(&mut rng);
@@ -798,7 +798,7 @@ mod tests {
use enr::secp256k1::SecretKey;
use std::net::Ipv4Addr;
let mut rng = rand::rngs::OsRng;
let mut rng = rand_08::rngs::OsRng;
let key = SecretKey::new(&mut rng);
let ip = Ipv4Addr::new(127, 0, 0, 1);
let tcp = 3000;
@@ -816,7 +816,7 @@ mod tests {
builder.build(&key).unwrap()
};
let enr_response = EnrResponse { request_hash: rng.gen(), enr };
let enr_response = EnrResponse { request_hash: B256::random(), enr };
let mut buf = Vec::new();
enr_response.encode(&mut buf);
@@ -908,7 +908,7 @@ mod tests {
use enr::{secp256k1::SecretKey, EnrPublicKey};
use std::net::Ipv4Addr;
let key = SecretKey::new(&mut rand::rngs::OsRng);
let key = SecretKey::new(&mut rand_08::rngs::OsRng);
let ip = Ipv4Addr::new(127, 0, 0, 1);
let tcp = 3000;

19
crates/net/discv4/src/test_utils.rs
View File

@@ -1,12 +1,14 @@
//! Mock discovery support
// TODO(rand): update ::random calls after rand_09 migration
use crate::{
proto::{FindNode, Message, Neighbours, NodeEndpoint, Packet, Ping, Pong},
receive_loop, send_loop, Discv4, Discv4Config, Discv4Service, EgressSender, IngressEvent,
IngressReceiver, PeerId, SAFE_MAX_DATAGRAM_NEIGHBOUR_RECORDS,
};
use alloy_primitives::{hex, B256};
use rand::{thread_rng, Rng, RngCore};
use alloy_primitives::{hex, B256, B512};
use rand_08::{thread_rng, Rng, RngCore};
use reth_ethereum_forks::{ForkHash, ForkId};
use reth_network_peers::{pk2id, NodeRecord};
use secp256k1::{SecretKey, SECP256K1};
@@ -265,7 +267,8 @@ pub fn rng_endpoint(rng: &mut impl Rng) -> NodeEndpoint {
/// Generates a random [`NodeRecord`] using the provided random number generator.
pub fn rng_record(rng: &mut impl RngCore) -> NodeRecord {
let NodeEndpoint { address, udp_port, tcp_port } = rng_endpoint(rng);
NodeRecord { address, tcp_port, udp_port, id: rng.gen() }
// TODO(rand)
NodeRecord { address, tcp_port, udp_port, id: B512::random() }
}
/// Generates a random IPv6 [`NodeRecord`] using the provided random number generator.
@@ -273,7 +276,8 @@ pub fn rng_ipv6_record(rng: &mut impl RngCore) -> NodeRecord {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
let address = IpAddr::V6(ip.into());
NodeRecord { address, tcp_port: rng.gen(), udp_port: rng.gen(), id: rng.gen() }
// TODO(rand)
NodeRecord { address, tcp_port: rng.gen(), udp_port: rng.gen(), id: B512::random() }
}
/// Generates a random IPv4 [`NodeRecord`] using the provided random number generator.
@@ -281,7 +285,8 @@ pub fn rng_ipv4_record(rng: &mut impl RngCore) -> NodeRecord {
let mut ip = [0u8; 4];
rng.fill_bytes(&mut ip);
let address = IpAddr::V4(ip.into());
NodeRecord { address, tcp_port: rng.gen(), udp_port: rng.gen(), id: rng.gen() }
// TODO(rand)
NodeRecord { address, tcp_port: rng.gen(), udp_port: rng.gen(), id: B512::random() }
}
/// Generates a random [`Message`] using the provided random number generator.
@@ -295,11 +300,11 @@ pub fn rng_message(rng: &mut impl RngCore) -> Message {
}),
2 => Message::Pong(Pong {
to: rng_endpoint(rng),
echo: rng.gen(),
echo: B256::random(),
expire: rng.gen(),
enr_sq: None,
}),
3 => Message::FindNode(FindNode { id: rng.gen(), expire: rng.gen() }),
3 => Message::FindNode(FindNode { id: B512::random(), expire: rng.gen() }),
4 => {
let num: usize = rng.gen_range(1..=SAFE_MAX_DATAGRAM_NEIGHBOUR_RECORDS);
Message::Neighbours(Neighbours {

1
crates/net/discv5/Cargo.toml
View File

@@ -43,3 +43,4 @@ metrics.workspace = true
reth-tracing.workspace = true
tokio = { workspace = true, features = ["rt-multi-thread"] }
secp256k1 = { workspace = true, features = ["std", "rand"] }
rand_08.workspace = true

6
crates/net/discv5/src/lib.rs
View File

@@ -600,7 +600,7 @@ pub fn get_lookup_target(
target[byte] ^= 1 << (7 - bit);
// Randomize the bits after the target.
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
// Randomize remaining bits in the byte we modified.
if bit < 7 {
// Compute the mask of the bits that need to be randomized.
@@ -608,7 +608,7 @@ pub fn get_lookup_target(
// Clear.
target[byte] &= !bits_to_randomize;
// Randomize.
target[byte] |= rng.gen::<u8>() & bits_to_randomize;
target[byte] |= rng.random::<u8>() & bits_to_randomize;
}
// Randomize remaining bytes.
rng.fill_bytes(&mut target[byte + 1..]);
@@ -655,7 +655,7 @@ pub async fn lookup(
mod test {
use super::*;
use ::enr::{CombinedKey, EnrKey};
use rand::thread_rng;
use rand_08::thread_rng;
use reth_chainspec::MAINNET;
use tracing::trace;

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

@@ -707,7 +707,7 @@ mod tests {
// calculate min for chunk byte length range, pick a lower bound that guarantees at least
// one block will be read
let chunk_byte_len = rand::thread_rng().gen_range(2000..=10_000);
let chunk_byte_len = rand::rng().random_range(2000..=10_000);
trace!(target: "downloaders::file::test", chunk_byte_len);
// init reader

2
crates/net/ecies/Cargo.toml
View File

@@ -31,10 +31,10 @@ typenum.workspace = true
byteorder.workspace = true
# crypto
rand.workspace = true
ctr.workspace = true
digest.workspace = true
secp256k1 = { workspace = true, features = ["global-context", "std", "recovery", "rand"] }
rand_08.workspace = true
concat-kdf.workspace = true
sha2.workspace = true
sha3.workspace = true

19
crates/net/ecies/src/algorithm.rs
View File

@@ -15,7 +15,7 @@ use alloy_rlp::{Encodable, Rlp, RlpEncodable, RlpMaxEncodedLen};
use byteorder::{BigEndian, ByteOrder, ReadBytesExt};
use ctr::Ctr64BE;
use digest::{crypto_common::KeyIvInit, Digest};
use rand::{thread_rng, Rng};
use rand_08::{thread_rng as rng, Rng};
use reth_network_peers::{id2pk, pk2id};
use secp256k1::{
ecdsa::{RecoverableSignature, RecoveryId},
@@ -312,8 +312,9 @@ impl ECIES {
/// Create a new ECIES client with the given static secret key and remote peer ID.
pub fn new_client(secret_key: SecretKey, remote_id: PeerId) -> Result<Self, ECIESError> {
let mut rng = thread_rng();
let nonce = rng.gen();
// TODO(rand): use rng for nonce
let mut rng = rng();
let nonce = B256::random();
let ephemeral_secret_key = SecretKey::new(&mut rng);
Self::new_static_client(secret_key, remote_id, nonce, ephemeral_secret_key)
}
@@ -354,8 +355,8 @@ impl ECIES {
/// Create a new ECIES server with the given static secret key.
pub fn new_server(secret_key: SecretKey) -> Result<Self, ECIESError> {
let mut rng = thread_rng();
let nonce = rng.gen();
let mut rng = rng();
let nonce = B256::random();
let ephemeral_secret_key = SecretKey::new(&mut rng);
Self::new_static_server(secret_key, nonce, ephemeral_secret_key)
}
@@ -366,7 +367,7 @@ impl ECIES {
}
fn encrypt_message(&self, data: &[u8], out: &mut BytesMut) {
let mut rng = thread_rng();
let mut rng = rng();
out.reserve(secp256k1::constants::UNCOMPRESSED_PUBLIC_KEY_SIZE + 16 + data.len() + 32);
@@ -382,7 +383,7 @@ impl ECIES {
let enc_key = B128::from_slice(&key[..16]);
let mac_key = sha256(&key[16..32]);
let iv: B128 = rng.gen();
let iv = B128::random();
let mut encryptor = Ctr64BE::<Aes128>::new((&enc_key.0).into(), (&iv.0).into());
let mut encrypted = data.to_vec();
@@ -442,7 +443,7 @@ impl ECIES {
}
.encode(&mut out);
out.resize(out.len() + thread_rng().gen_range(100..=300), 0);
out.resize(out.len() + rng().gen_range(100..=300), 0);
out
}
@@ -763,7 +764,7 @@ mod tests {
#[test]
fn communicate() {
let mut rng = thread_rng();
let mut rng = rng();
let server_secret_key = SecretKey::new(&mut rng);
let server_public_key = PublicKey::from_secret_key(SECP256K1, &server_secret_key);
let client_secret_key = SecretKey::new(&mut rng);

8
crates/net/ecies/src/stream.rs
View File

@@ -180,7 +180,7 @@ mod tests {
async fn can_write_and_read() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server_key = SecretKey::new(&mut rand::thread_rng());
let server_key = SecretKey::new(&mut rand_08::thread_rng());
let handle = tokio::spawn(async move {
// roughly based off of the design of tokio::net::TcpListener
@@ -195,7 +195,7 @@ mod tests {
// create the server pubkey
let server_id = pk2id(&server_key.public_key(SECP256K1));
let client_key = SecretKey::new(&mut rand::thread_rng());
let client_key = SecretKey::new(&mut rand_08::thread_rng());
let outgoing = TcpStream::connect(addr).await.unwrap();
let mut client_stream =
ECIESStream::connect(outgoing, client_key, server_id).await.unwrap();
@@ -209,7 +209,7 @@ mod tests {
async fn connection_should_timeout() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server_key = SecretKey::new(&mut rand::thread_rng());
let server_key = SecretKey::new(&mut rand_08::thread_rng());
let _handle = tokio::spawn(async move {
// Delay accepting the connection for longer than the client's timeout period
@@ -225,7 +225,7 @@ mod tests {
// create the server pubkey
let server_id = pk2id(&server_key.public_key(SECP256K1));
let client_key = SecretKey::new(&mut rand::thread_rng());
let client_key = SecretKey::new(&mut rand_08::thread_rng());
let outgoing = TcpStream::connect(addr).await.unwrap();
// Attempt to connect, expecting a timeout due to the server's delayed response

2
crates/net/eth-wire-types/src/blocks.rs
View File

@@ -97,7 +97,7 @@ mod tests {
};
use alloy_consensus::{Header, TxLegacy};
use alloy_eips::BlockHashOrNumber;
use alloy_primitives::{hex, PrimitiveSignature as Signature, TxKind, U256};
use alloy_primitives::{hex, Signature, TxKind, U256};
use alloy_rlp::{Decodable, Encodable};
use reth_ethereum_primitives::{BlockBody, Transaction, TransactionSigned};
use std::str::FromStr;

2
crates/net/eth-wire-types/src/broadcast.rs
View File

@@ -770,7 +770,7 @@ mod tests {
use super::*;
use alloy_consensus::Typed2718;
use alloy_eips::eip2718::Encodable2718;
use alloy_primitives::{b256, hex, PrimitiveSignature as Signature, U256};
use alloy_primitives::{b256, hex, Signature, U256};
use reth_ethereum_primitives::{Transaction, TransactionSigned};
use std::str::FromStr;

8
crates/net/eth-wire-types/src/status.rs
View File

@@ -582,12 +582,12 @@ mod tests {
#[test]
fn init_custom_status_fields() {
let mut rng = rand::thread_rng();
let head_hash = rng.gen();
let total_difficulty = U256::from(rng.gen::<u64>());
let mut rng = rand::rng();
let head_hash = rng.random();
let total_difficulty = U256::from(rng.random::<u64>());
// create a genesis that has a random part, so we can check that the hash is preserved
let genesis = Genesis { nonce: rng.gen(), ..Default::default() };
let genesis = Genesis { nonce: rng.random(), ..Default::default() };
// build head
let head = Head {

2
crates/net/eth-wire-types/src/transactions.rs
View File

@@ -86,7 +86,7 @@ impl<T> Default for PooledTransactions<T> {
mod tests {
use crate::{message::RequestPair, GetPooledTransactions, PooledTransactions};
use alloy_consensus::{transaction::PooledTransaction, TxEip1559, TxLegacy};
use alloy_primitives::{hex, PrimitiveSignature as Signature, TxKind, U256};
use alloy_primitives::{hex, Signature, TxKind, U256};
use alloy_rlp::{Decodable, Encodable};
use reth_chainspec::MIN_TRANSACTION_GAS;
use reth_ethereum_primitives::{Transaction, TransactionSigned};

2
crates/net/eth-wire/Cargo.toml
View File

@@ -54,6 +54,7 @@ tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
tokio-util = { workspace = true, features = ["io", "codec"] }
rand.workspace = true
secp256k1 = { workspace = true, features = ["global-context", "std", "recovery"] }
rand_08.workspace = true
arbitrary = { workspace = true, features = ["derive"] }
proptest.workspace = true
@@ -87,6 +88,7 @@ serde = [
"reth-primitives-traits/serde",
"reth-ethereum-forks/serde",
"alloy-consensus/serde",
"rand_08/serde",
]
[[test]]

8
crates/net/eth-wire/src/ethstream.rs
View File

@@ -536,7 +536,7 @@ mod tests {
async fn can_write_and_read_ecies() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let local_addr = listener.local_addr().unwrap();
let server_key = SecretKey::new(&mut rand::thread_rng());
let server_key = SecretKey::new(&mut rand_08::thread_rng());
let test_msg = EthMessage::<EthNetworkPrimitives>::NewBlockHashes(
vec![
BlockHashNumber { hash: B256::random(), number: 5 },
@@ -560,7 +560,7 @@ mod tests {
// create the server pubkey
let server_id = pk2id(&server_key.public_key(SECP256K1));
let client_key = SecretKey::new(&mut rand::thread_rng());
let client_key = SecretKey::new(&mut rand_08::thread_rng());
let outgoing = TcpStream::connect(local_addr).await.unwrap();
let outgoing = ECIESStream::connect(outgoing, client_key, server_id).await.unwrap();
@@ -578,7 +578,7 @@ mod tests {
// create tcpstream
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let local_addr = listener.local_addr().unwrap();
let server_key = SecretKey::new(&mut rand::thread_rng());
let server_key = SecretKey::new(&mut rand_08::thread_rng());
let test_msg = EthMessage::<EthNetworkPrimitives>::NewBlockHashes(
vec![
BlockHashNumber { hash: B256::random(), number: 5 },
@@ -631,7 +631,7 @@ mod tests {
// create the server pubkey
let server_id = pk2id(&server_key.public_key(SECP256K1));
let client_key = SecretKey::new(&mut rand::thread_rng());
let client_key = SecretKey::new(&mut rand_08::thread_rng());
let outgoing = TcpStream::connect(local_addr).await.unwrap();
let sink = ECIESStream::connect(outgoing, client_key, server_id).await.unwrap();

10
crates/net/eth-wire/src/hello.rs
View File

@@ -47,7 +47,7 @@ impl HelloMessageWithProtocols {
/// use reth_eth_wire::HelloMessageWithProtocols;
/// use reth_network_peers::pk2id;
/// use secp256k1::{SecretKey, SECP256K1};
/// let secret_key = SecretKey::new(&mut rand::thread_rng());
/// let secret_key = SecretKey::new(&mut rand_08::thread_rng());
/// let id = pk2id(&secret_key.public_key(SECP256K1));
/// let status = HelloMessageWithProtocols::builder(id).build();
/// ```
@@ -130,7 +130,7 @@ impl HelloMessage {
/// use reth_eth_wire::HelloMessage;
/// use reth_network_peers::pk2id;
/// use secp256k1::{SecretKey, SECP256K1};
/// let secret_key = SecretKey::new(&mut rand::thread_rng());
/// let secret_key = SecretKey::new(&mut rand_08::thread_rng());
/// let id = pk2id(&secret_key.public_key(SECP256K1));
/// let status = HelloMessage::builder(id).build();
/// ```
@@ -222,7 +222,7 @@ mod tests {
#[test]
fn test_hello_encoding_round_trip() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let id = pk2id(&secret_key.public_key(SECP256K1));
let hello = P2PMessage::Hello(HelloMessage {
protocol_version: ProtocolVersion::V5,
@@ -242,7 +242,7 @@ mod tests {
#[test]
fn hello_encoding_length() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let id = pk2id(&secret_key.public_key(SECP256K1));
let hello = P2PMessage::Hello(HelloMessage {
protocol_version: ProtocolVersion::V5,
@@ -261,7 +261,7 @@ mod tests {
#[test]
fn hello_message_id_prefix() {
// ensure that the hello message id is prefixed
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let id = pk2id(&secret_key.public_key(SECP256K1));
let hello = P2PMessage::Hello(HelloMessage {
protocol_version: ProtocolVersion::V5,

2
crates/net/eth-wire/src/test_utils.rs
View File

@@ -19,7 +19,7 @@ pub type P2pPassthroughTcpStream = P2PStream<Framed<TcpStream, LengthDelimitedCo
/// Returns a new testing `HelloMessage` and new secretkey
pub fn eth_hello() -> (HelloMessageWithProtocols, SecretKey) {
let server_key = SecretKey::new(&mut rand::thread_rng());
let server_key = SecretKey::new(&mut rand_08::thread_rng());
let protocols = vec![EthVersion::Eth67.into()];
let hello = HelloMessageWithProtocols {
protocol_version: ProtocolVersion::V5,

2
crates/net/network/Cargo.toml
View File

@@ -67,6 +67,7 @@ rustc-hash.workspace = true
thiserror.workspace = true
parking_lot.workspace = true
rand.workspace = true
rand_08.workspace = true
secp256k1 = { workspace = true, features = ["global-context", "std", "recovery"] }
derive_more.workspace = true
schnellru.workspace = true
@@ -125,6 +126,7 @@ serde = [
"reth-transaction-pool/serde",
"reth-ethereum-primitives/serde",
"reth-network-api/serde",
"rand_08/serde",
]
test-utils = [
"reth-transaction-pool/test-utils",

11
crates/net/network/benches/broadcast.rs
View File

@@ -1,10 +1,8 @@
#![allow(missing_docs)]
use alloy_primitives::{
private::proptest::test_runner::{RngAlgorithm, TestRng},
U256,
};
use alloy_primitives::U256;
use criterion::*;
use futures::StreamExt;
use rand::SeedableRng;
use reth_network::{test_utils::Testnet, NetworkEventListenerProvider};
use reth_network_api::Peers;
use reth_provider::test_utils::{ExtendedAccount, MockEthProvider};
@@ -50,9 +48,8 @@ pub fn broadcast_ingress_bench(c: &mut Criterion) {
}
// prepare some transactions
let mut gen = TransactionGenerator::new(TestRng::deterministic_rng(
RngAlgorithm::ChaCha,
));
let mut gen =
TransactionGenerator::new(rand::rngs::StdRng::seed_from_u64(0));
let num_broadcasts = 10;
for _ in 0..num_broadcasts {
for _ in 0..2 {

11
crates/net/network/benches/tx_manager_hash_fetching.rs
View File

@@ -1,10 +1,8 @@
#![allow(missing_docs)]
use alloy_primitives::{
private::proptest::test_runner::{RngAlgorithm, TestRng},
U256,
};
use alloy_primitives::U256;
use criterion::*;
use rand::SeedableRng;
use reth_network::{
test_utils::Testnet,
transactions::{
@@ -63,9 +61,8 @@ pub fn tx_fetch_bench(c: &mut Criterion) {
let peer_pool = peer.pool().unwrap();
for _ in 0..num_tx_per_peer {
let mut gen = TransactionGenerator::new(
TestRng::deterministic_rng(RngAlgorithm::ChaCha),
);
let mut gen =
TransactionGenerator::new(rand::rngs::StdRng::seed_from_u64(0));
let tx = gen.gen_eip1559_pooled();
let sender = tx.sender();

5
crates/net/network/src/config.rs
View File

@@ -28,7 +28,7 @@ pub use secp256k1::SecretKey;
/// Convenience function to create a new random [`SecretKey`]
pub fn rng_secret_key() -> SecretKey {
SecretKey::new(&mut rand::thread_rng())
SecretKey::new(&mut rand_08::thread_rng())
}
/// All network related initialization settings.
@@ -696,14 +696,13 @@ impl NetworkMode {
mod tests {
use super::*;
use alloy_eips::eip2124::ForkHash;
use rand::thread_rng;
use reth_chainspec::{Chain, MAINNET};
use reth_dns_discovery::tree::LinkEntry;
use reth_storage_api::noop::NoopProvider;
use std::sync::Arc;
fn builder() -> NetworkConfigBuilder {
let secret_key = SecretKey::new(&mut thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
NetworkConfigBuilder::new(secret_key)
}

6
crates/net/network/src/discovery.rs
View File

@@ -338,14 +338,12 @@ impl Discovery {
#[cfg(test)]
mod tests {
use super::*;
use rand::thread_rng;
use secp256k1::SECP256K1;
use std::net::{Ipv4Addr, SocketAddrV4};
#[tokio::test(flavor = "multi_thread")]
async fn test_discovery_setup() {
let mut rng = thread_rng();
let (secret_key, _) = SECP256K1.generate_keypair(&mut rng);
let (secret_key, _) = SECP256K1.generate_keypair(&mut rand_08::thread_rng());
let discovery_addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0));
let _discovery = Discovery::new(
discovery_addr,
@@ -364,7 +362,7 @@ mod tests {
use tracing::trace;
async fn start_discovery_node(udp_port_discv4: u16, udp_port_discv5: u16) -> Discovery {
let secret_key = SecretKey::new(&mut thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let discv4_addr = format!("127.0.0.1:{udp_port_discv4}").parse().unwrap();
let discv5_addr: SocketAddr = format!("127.0.0.1:{udp_port_discv5}").parse().unwrap();

4
crates/net/network/src/session/active.rs
View File

@@ -898,7 +898,7 @@ mod tests {
let fork_filter = self.fork_filter.clone();
let local_peer_id = self.local_peer_id;
let mut hello = self.hello.clone();
let key = SecretKey::new(&mut rand::thread_rng());
let key = SecretKey::new(&mut rand_08::thread_rng());
hello.id = pk2id(&key.public_key(SECP256K1));
Box::pin(async move {
let outgoing = TcpStream::connect(local_addr).await.unwrap();
@@ -989,7 +989,7 @@ mod tests {
fn default() -> Self {
let (active_session_tx, active_session_rx) = mpsc::channel(100);
let (secret_key, pk) = SECP256K1.generate_keypair(&mut rand::thread_rng());
let (secret_key, pk) = SECP256K1.generate_keypair(&mut rand_08::thread_rng());
let local_peer_id = pk2id(&pk);
Self {

2
crates/net/network/src/state.rs
View File

@@ -195,7 +195,7 @@ impl<N: NetworkPrimitives> NetworkState<N> {
// Shuffle to propagate to a random sample of peers on every block announcement
let mut peers: Vec<_> = self.active_peers.iter_mut().collect();
peers.shuffle(&mut rand::thread_rng());
peers.shuffle(&mut rand::rng());
for (peer_id, peer) in peers {
if peer.blocks.contains(&msg.hash) {

4
crates/net/network/src/test_utils/testnet.rs
View File

@@ -638,7 +638,7 @@ where
where
C: ChainSpecProvider<ChainSpec: Hardforks>,
{
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = Self::network_config_builder(secret_key).build(client.clone());
Self { config, client, secret_key }
}
@@ -658,7 +658,7 @@ where
where
C: ChainSpecProvider<ChainSpec: Hardforks>,
{
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let builder = Self::network_config_builder(secret_key);
let hello_message =

14
crates/net/network/src/transactions/mod.rs
View File

@@ -1911,7 +1911,7 @@ mod tests {
use super::*;
use crate::{test_utils::Testnet, NetworkConfigBuilder, NetworkManager};
use alloy_consensus::{transaction::PooledTransaction, TxEip1559, TxLegacy};
use alloy_primitives::{hex, PrimitiveSignature as Signature, TxKind, U256};
use alloy_primitives::{hex, Signature, TxKind, U256};
use alloy_rlp::Decodable;
use constants::tx_fetcher::DEFAULT_MAX_COUNT_FALLBACK_PEERS;
use futures::FutureExt;
@@ -1940,7 +1940,7 @@ mod tests {
async fn new_tx_manager(
) -> (TransactionsManager<TestPool, EthNetworkPrimitives>, NetworkManager<EthNetworkPrimitives>)
{
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let config = NetworkConfigBuilder::new(secret_key)
@@ -1998,7 +1998,7 @@ mod tests {
let listener0 = handle0.event_listener();
handle0.add_peer(*handle1.peer_id(), handle1.local_addr());
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let pool = testing_pool();
@@ -2066,7 +2066,7 @@ mod tests {
let listener0 = handle0.event_listener();
handle0.add_peer(*handle1.peer_id(), handle1.local_addr());
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let pool = testing_pool();
@@ -2131,7 +2131,7 @@ mod tests {
async fn test_handle_incoming_transactions_hashes() {
reth_tracing::init_test_tracing();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let config = NetworkConfigBuilder::new(secret_key)
@@ -2238,7 +2238,7 @@ mod tests {
let listener0 = handle0.event_listener();
handle0.add_peer(*handle1.peer_id(), handle1.local_addr());
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let pool = testing_pool();
@@ -2314,7 +2314,7 @@ mod tests {
let listener0 = handle0.event_listener();
handle0.add_peer(*handle1.peer_id(), handle1.local_addr());
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let pool = testing_pool();

2
crates/net/network/src/transactions/validation.rs
View File

@@ -3,7 +3,7 @@
//! announcements. Validation and filtering of announcements is network dependent.
use crate::metrics::{AnnouncedTxTypesMetrics, TxTypesCounter};
use alloy_primitives::{PrimitiveSignature as Signature, TxHash};
use alloy_primitives::{Signature, TxHash};
use derive_more::{Deref, DerefMut};
use reth_eth_wire::{
DedupPayload, Eth68TxMetadata, HandleMempoolData, PartiallyValidData, ValidAnnouncementData,

2
crates/net/network/tests/it/big_pooled_txs_req.rs
View File

@@ -1,4 +1,4 @@
use alloy_primitives::{PrimitiveSignature as Signature, B256};
use alloy_primitives::{Signature, B256};
use reth_eth_wire::{GetPooledTransactions, PooledTransactions};
use reth_ethereum_primitives::TransactionSigned;
use reth_network::{

36
crates/net/network/tests/it/connect.rs
View File

@@ -93,7 +93,7 @@ async fn test_already_connected() {
reth_tracing::init_test_tracing();
let mut net = Testnet::default();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let p1 = PeerConfig::default();
@@ -137,8 +137,8 @@ async fn test_get_peer() {
reth_tracing::init_test_tracing();
let mut net = Testnet::default();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key_1 = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let secret_key_1 = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let p1 = PeerConfig::default();
@@ -171,8 +171,8 @@ async fn test_get_peer_by_id() {
reth_tracing::init_test_tracing();
let mut net = Testnet::default();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key_1 = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let secret_key_1 = SecretKey::new(&mut rand_08::thread_rng());
let client = NoopProvider::default();
let p1 = PeerConfig::default();
let p2 = PeerConfig::with_secret_key(client.clone(), secret_key);
@@ -204,7 +204,7 @@ async fn test_get_peer_by_id() {
#[ignore]
async fn test_connect_with_boot_nodes() {
reth_tracing::init_test_tracing();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let mut discv4 = Discv4Config::builder();
discv4.add_boot_nodes(mainnet_nodes());
@@ -225,7 +225,7 @@ async fn test_connect_with_boot_nodes() {
#[ignore]
async fn test_connect_with_builder() {
reth_tracing::init_test_tracing();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let mut discv4 = Discv4Config::builder();
discv4.add_boot_nodes(mainnet_nodes());
@@ -262,7 +262,7 @@ async fn test_connect_with_builder() {
#[ignore]
async fn test_connect_to_trusted_peer() {
reth_tracing::init_test_tracing();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let discv4 = Discv4Config::builder();
let client = NoopProvider::default();
@@ -319,7 +319,7 @@ async fn test_connect_to_trusted_peer() {
async fn test_incoming_node_id_blacklist() {
reth_tracing::init_test_tracing();
tokio::time::timeout(GETH_TIMEOUT, async move {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
// instantiate geth and add ourselves as a peer
let temp_dir = tempfile::tempdir().unwrap().into_path();
@@ -374,7 +374,7 @@ async fn test_incoming_node_id_blacklist() {
async fn test_incoming_connect_with_single_geth() {
reth_tracing::init_test_tracing();
tokio::time::timeout(GETH_TIMEOUT, async move {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
// instantiate geth and add ourselves as a peer
let temp_dir = tempfile::tempdir().unwrap().into_path();
@@ -419,7 +419,7 @@ async fn test_incoming_connect_with_single_geth() {
async fn test_outgoing_connect_with_single_geth() {
reth_tracing::init_test_tracing();
tokio::time::timeout(GETH_TIMEOUT, async move {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::new(secret_key)
.listener_port(0)
@@ -466,7 +466,7 @@ async fn test_outgoing_connect_with_single_geth() {
async fn test_geth_disconnect() {
reth_tracing::init_test_tracing();
tokio::time::timeout(GETH_TIMEOUT, async move {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.listener_port(0)
@@ -587,7 +587,7 @@ async fn test_trusted_peer_only() {
drop(handles);
let _handle = net.spawn();
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let peers_config = PeersConfig::default().with_trusted_nodes_only(true);
let config = NetworkConfigBuilder::eth(secret_key)
@@ -639,7 +639,7 @@ async fn test_trusted_peer_only() {
#[tokio::test(flavor = "multi_thread")]
async fn test_network_state_change() {
let net = Testnet::create(1).await;
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let peers_config =
PeersConfig::default().with_refill_slots_interval(Duration::from_millis(500));
@@ -681,7 +681,7 @@ async fn test_network_state_change() {
#[tokio::test(flavor = "multi_thread")]
async fn test_exceed_outgoing_connections() {
let net = Testnet::create(2).await;
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let peers_config = PeersConfig::default().with_max_outbound(1);
let config = NetworkConfigBuilder::eth(secret_key)
@@ -722,7 +722,7 @@ async fn test_exceed_outgoing_connections() {
#[tokio::test(flavor = "multi_thread")]
async fn test_disconnect_incoming_when_exceeded_incoming_connections() {
let net = Testnet::create(1).await;
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let peers_config = PeersConfig::default().with_max_inbound(0);
let config = NetworkConfigBuilder::eth(secret_key)
@@ -838,7 +838,7 @@ async fn new_random_peer(
max_in_bound: usize,
trusted_nodes: Vec<TrustedPeer>,
) -> NetworkManager<EthNetworkPrimitives> {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let peers_config =
PeersConfig::default().with_max_inbound(max_in_bound).with_trusted_nodes(trusted_nodes);
@@ -909,7 +909,7 @@ async fn test_connect_peer_in_different_network_should_fail() {
tokio::task::spawn(peer);
// peer in sepolia.
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
// If the remote disconnect first, then we would not get a fatal protocol error. So set
// max_backoff_count to 0 to speed up the removal of the peer.
let peers_config = PeersConfig::default().with_max_backoff_count(0);

2
crates/net/network/tests/it/multiplex.rs
View File

@@ -283,7 +283,7 @@ async fn test_connect_to_non_multiplex_peer() {
let net = Testnet::create(1).await;
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.listener_port(0)

24
crates/net/network/tests/it/requests.rs
View File

@@ -4,7 +4,7 @@
use std::sync::Arc;
use alloy_consensus::{Header, TxEip2930};
use alloy_primitives::{Bytes, PrimitiveSignature as Signature, TxKind, U256};
use alloy_primitives::{Bytes, Signature, TxKind, U256};
use rand::Rng;
use reth_eth_wire::HeadersDirection;
use reth_ethereum_primitives::{Block, Transaction, TransactionSigned};
@@ -22,12 +22,12 @@ use reth_provider::test_utils::MockEthProvider;
/// Returns a new [`TransactionSigned`] with some random parameters
pub fn rng_transaction(rng: &mut impl rand::RngCore) -> TransactionSigned {
let request = Transaction::Eip2930(TxEip2930 {
chain_id: rng.gen(),
nonce: rng.gen(),
gas_price: rng.gen(),
gas_limit: rng.gen(),
chain_id: rng.random(),
nonce: rng.random(),
gas_price: rng.random(),
gas_limit: rng.random(),
to: TxKind::Create,
value: U256::from(rng.gen::<u128>()),
value: U256::from(rng.random::<u128>()),
input: Bytes::from(vec![1, 2]),
access_list: Default::default(),
});
@@ -39,7 +39,7 @@ pub fn rng_transaction(rng: &mut impl rand::RngCore) -> TransactionSigned {
#[tokio::test(flavor = "multi_thread")]
async fn test_get_body() {
reth_tracing::init_test_tracing();
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
let mock_provider = Arc::new(MockEthProvider::default());
let mut net = Testnet::create_with(2, mock_provider.clone()).await;
@@ -63,7 +63,7 @@ async fn test_get_body() {
// request some blocks
for _ in 0..100 {
// Set a new random block to the mock storage and request it via the network
let block_hash = rng.gen();
let block_hash = rng.random();
let mut block: Block = Block::default();
block.body.transactions.push(rng_transaction(&mut rng));
@@ -81,7 +81,7 @@ async fn test_get_body() {
#[tokio::test(flavor = "multi_thread")]
async fn test_get_header() {
reth_tracing::init_test_tracing();
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
let mock_provider = Arc::new(MockEthProvider::default());
let mut net = Testnet::create_with(2, mock_provider.clone()).await;
@@ -102,13 +102,13 @@ async fn test_get_header() {
let connected = events0.next_session_established().await.unwrap();
assert_eq!(connected, *handle1.peer_id());
let start: u64 = rng.gen();
let mut hash = rng.gen();
let start: u64 = rng.random();
let mut hash = rng.random();
// request some headers
for idx in 0..100 {
// Set a new random header to the mock storage and request it via the network
let header = Header { number: start + idx, parent_hash: hash, ..Default::default() };
hash = rng.gen();
hash = rng.random();
mock_provider.add_header(hash, header.clone());

14
crates/net/network/tests/it/startup.rs
View File

@@ -25,7 +25,7 @@ fn is_addr_in_use_kind(err: &NetworkError, kind: ServiceKind) -> bool {
#[tokio::test(flavor = "multi_thread")]
async fn test_is_default_syncing() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.disable_discovery()
.listener_port(0)
@@ -36,7 +36,7 @@ async fn test_is_default_syncing() {
#[tokio::test(flavor = "multi_thread")]
async fn test_listener_addr_in_use() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.disable_discovery()
.listener_port(0)
@@ -55,7 +55,7 @@ async fn test_listener_addr_in_use() {
#[tokio::test(flavor = "multi_thread")]
async fn test_discovery_addr_in_use() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let disc_config = Discv4Config::default();
let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0));
let any_port_listener = TcpListener::bind(addr).await.unwrap();
@@ -71,7 +71,7 @@ async fn test_discovery_addr_in_use() {
// <https://github.com/paradigmxyz/reth/issues/8851>
#[tokio::test(flavor = "multi_thread")]
async fn test_tcp_port_node_record_no_discovery() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.listener_port(0)
.disable_discovery()
@@ -89,7 +89,7 @@ async fn test_tcp_port_node_record_no_discovery() {
// <https://github.com/paradigmxyz/reth/issues/8851>
#[tokio::test(flavor = "multi_thread")]
async fn test_tcp_port_node_record_discovery() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.listener_port(0)
.discovery_port(0)
@@ -108,7 +108,7 @@ async fn test_tcp_port_node_record_discovery() {
#[tokio::test(flavor = "multi_thread")]
async fn test_node_record_address_with_nat() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.add_nat(Some(NatResolver::ExternalIp("10.1.1.1".parse().unwrap())))
.disable_discv4_discovery()
@@ -124,7 +124,7 @@ async fn test_node_record_address_with_nat() {
#[tokio::test(flavor = "multi_thread")]
async fn test_node_record_address_with_nat_disable_discovery() {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let secret_key = SecretKey::new(&mut rand_08::thread_rng());
let config = NetworkConfigBuilder::eth(secret_key)
.add_nat(Some(NatResolver::ExternalIp("10.1.1.1".parse().unwrap())))
.disable_discovery()

3
crates/net/network/tests/it/transaction_hash_fetching.rs
View File

@@ -1,5 +1,4 @@
use alloy_primitives::U256;
use rand::thread_rng;
use reth_network::{
test_utils::Testnet,
transactions::{TransactionPropagationMode::Max, TransactionsManagerConfig},
@@ -40,7 +39,7 @@ async fn transaction_hash_fetching() {
let peer_pool = peer.pool().unwrap();
for _ in 0..num_tx_per_peer {
let mut gen = TransactionGenerator::new(thread_rng());
let mut gen = TransactionGenerator::new(rand::rng());
let tx = gen.gen_eip1559_pooled();
let sender = tx.sender();
provider.add_account(sender, ExtendedAccount::new(0, U256::from(100_000_000)));

7
crates/net/network/tests/it/txgossip.rs
View File

@@ -3,9 +3,8 @@
use std::sync::Arc;
use alloy_consensus::TxLegacy;
use alloy_primitives::{PrimitiveSignature as Signature, U256};
use alloy_primitives::{Signature, U256};
use futures::StreamExt;
use rand::thread_rng;
use reth_ethereum_primitives::TransactionSigned;
use reth_network::{test_utils::Testnet, NetworkEvent, NetworkEventListenerProvider};
use reth_network_api::{events::PeerEvent, PeersInfo};
@@ -33,7 +32,7 @@ async fn test_tx_gossip() {
let mut peer0_tx_listener = peer0.pool().unwrap().pending_transactions_listener();
let mut peer1_tx_listener = peer1.pool().unwrap().pending_transactions_listener();
let mut gen = TransactionGenerator::new(thread_rng());
let mut gen = TransactionGenerator::new(rand::rng());
let tx = gen.gen_eip1559_pooled();
// ensure the sender has balance
@@ -70,7 +69,7 @@ async fn test_4844_tx_gossip_penalization() {
let mut peer1_tx_listener = peer1.pool().unwrap().pending_transactions_listener();
let mut gen = TransactionGenerator::new(thread_rng());
let mut gen = TransactionGenerator::new(rand::rng());
// peer 0 will be penalized for sending txs[0] over gossip
let txs = vec![gen.gen_eip4844_pooled(), gen.gen_eip1559_pooled()];

1
crates/net/peers/Cargo.toml
View File

@@ -33,6 +33,7 @@ secp256k1 = { workspace = true, features = ["rand"] }
serde_json.workspace = true
enr.workspace = true
tokio = { workspace = true, features = ["net", "macros", "rt"] }
rand_08.workspace = true
[features]
default = ["std"]

2
crates/net/peers/src/lib.rs
View File

@@ -327,7 +327,7 @@ mod tests {
#[test]
#[cfg(feature = "secp256k1")]
fn pk2id2pk() {
let prikey = secp256k1::SecretKey::new(&mut rand::thread_rng());
let prikey = secp256k1::SecretKey::new(&mut rand_08::thread_rng());
let pubkey = secp256k1::PublicKey::from_secret_key(secp256k1::SECP256K1, &prikey);
assert_eq!(pubkey, id2pk(pk2id(&pubkey)).unwrap());
}

34
crates/net/peers/src/node_record.rs
View File

@@ -236,21 +236,21 @@ impl TryFrom<&Enr<secp256k1::SecretKey>> for NodeRecord {
mod tests {
use super::*;
use alloy_rlp::Decodable;
use rand::{thread_rng, Rng, RngCore};
use rand::{rng, Rng, RngCore};
use std::net::Ipv6Addr;
#[test]
fn test_mapped_ipv6() {
let mut rng = thread_rng();
let mut rng = rng();
let v4: Ipv4Addr = "0.0.0.0".parse().unwrap();
let v6 = v4.to_ipv6_mapped();
let record = NodeRecord {
address: v6.into(),
tcp_port: rng.gen(),
udp_port: rng.gen(),
id: rng.gen(),
tcp_port: rng.random(),
udp_port: rng.random(),
id: rng.random(),
};
assert!(record.clone().convert_ipv4_mapped());
@@ -259,14 +259,14 @@ mod tests {
#[test]
fn test_mapped_ipv4() {
let mut rng = thread_rng();
let mut rng = rng();
let v4: Ipv4Addr = "0.0.0.0".parse().unwrap();
let record = NodeRecord {
address: v4.into(),
tcp_port: rng.gen(),
udp_port: rng.gen(),
id: rng.gen(),
tcp_port: rng.random(),
udp_port: rng.random(),
id: rng.random(),
};
assert!(!record.clone().convert_ipv4_mapped());
@@ -275,15 +275,15 @@ mod tests {
#[test]
fn test_noderecord_codec_ipv4() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 4];
rng.fill_bytes(&mut ip);
let record = NodeRecord {
address: IpAddr::V4(ip.into()),
tcp_port: rng.gen(),
udp_port: rng.gen(),
id: rng.gen(),
tcp_port: rng.random(),
udp_port: rng.random(),
id: rng.random(),
};
let decoded = NodeRecord::decode(&mut alloy_rlp::encode(record).as_slice()).unwrap();
@@ -293,15 +293,15 @@ mod tests {
#[test]
fn test_noderecord_codec_ipv6() {
let mut rng = thread_rng();
let mut rng = rng();
for _ in 0..100 {
let mut ip = [0u8; 16];
rng.fill_bytes(&mut ip);
let record = NodeRecord {
address: IpAddr::V6(ip.into()),
tcp_port: rng.gen(),
udp_port: rng.gen(),
id: rng.gen(),
tcp_port: rng.random(),
udp_port: rng.random(),
id: rng.random(),
};
let decoded = NodeRecord::decode(&mut alloy_rlp::encode(record).as_slice()).unwrap();

7
crates/node/core/src/args/rpc_server.rs
View File

@@ -282,11 +282,8 @@ impl RpcServerArgs {
/// Append a random string to the ipc path, to prevent possible collisions when multiple nodes
/// are being run on the same machine.
pub fn with_ipc_random_path(mut self) -> Self {
let random_string: String = rand::thread_rng()
.sample_iter(rand::distributions::Alphanumeric)
.take(8)
.map(char::from)
.collect();
let random_string: String =
rand::rng().sample_iter(rand::distr::Alphanumeric).take(8).map(char::from).collect();
self.ipcpath = format!("{}-{}", self.ipcpath, random_string);
self
}

2
crates/optimism/cli/src/ovm_file_codec.rs
View File

@@ -9,7 +9,7 @@ use alloy_eips::{
};
use alloy_primitives::{
bytes::{Buf, BytesMut},
keccak256, PrimitiveSignature as Signature, TxHash, B256, U256,
keccak256, Signature, TxHash, B256, U256,
};
use alloy_rlp::{Decodable, Error as RlpError, RlpDecodable};
use derive_more::{AsRef, Deref};

4
crates/optimism/evm/src/execute.rs
View File

@@ -24,9 +24,7 @@ mod tests {
use super::*;
use crate::OpChainSpec;
use alloy_consensus::{Block, BlockBody, Header, TxEip1559};
use alloy_primitives::{
b256, Address, PrimitiveSignature as Signature, StorageKey, StorageValue, U256,
};
use alloy_primitives::{b256, Address, Signature, StorageKey, StorageValue, U256};
use op_alloy_consensus::{OpTypedTransaction, TxDeposit};
use op_revm::constants::L1_BLOCK_CONTRACT;
use reth_chainspec::MIN_TRANSACTION_GAS;

2
crates/optimism/payload/src/builder.rs
View File

@@ -384,7 +384,7 @@ impl<Txs> OpBuilder<'_, Txs> {
let ExecutionWitnessRecord { hashed_state, codes, keys } =
ExecutionWitnessRecord::from_executed_state(&db);
let state = state_provider.witness(Default::default(), hashed_state)?;
Ok(ExecutionWitness { state: state.into_iter().collect(), codes, keys })
Ok(ExecutionWitness { state: state.into_iter().collect(), codes, keys, headers: vec![] })
}
}

8
crates/optimism/primitives/Cargo.toml
View File

@@ -41,7 +41,7 @@ serde_with = { workspace = true, optional = true }
# misc
derive_more = { workspace = true, features = ["deref", "from", "into", "constructor"] }
rand = { workspace = true, optional = true }
rand_08 = { workspace = true, optional = true }
# test
arbitrary = { workspace = true, features = ["derive"], optional = true }
@@ -52,6 +52,7 @@ arbitrary.workspace = true
proptest-arbitrary-interop.workspace = true
proptest.workspace = true
rand.workspace = true
rand_08.workspace = true
reth-codecs = { workspace = true, features = ["test-utils", "op"] }
rstest.workspace = true
secp256k1 = { workspace = true, features = ["rand"] }
@@ -101,11 +102,12 @@ serde = [
"bytes?/serde",
"reth-codecs?/serde",
"op-alloy-consensus/serde",
"rand?/serde",
"rand_08?/serde",
"secp256k1?/serde",
"op-revm/serde",
"alloy-rpc-types-eth?/serde",
"revm-context/serde",
"rand/serde",
]
serde-bincode-compat = [
"serde",
@@ -126,7 +128,7 @@ arbitrary = [
"alloy-consensus/arbitrary",
"alloy-eips/arbitrary",
"alloy-primitives/arbitrary",
"rand",
"rand_08",
"alloy-rpc-types-eth?/arbitrary",
"alloy-serde?/arbitrary",
]

2
crates/optimism/primitives/src/receipt.rs
View File

@@ -439,7 +439,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(bytes.as_mut_slice());
rand::rng().fill(bytes.as_mut_slice());
let mut data = Data {
reseipt: OpReceipt::arbitrary(&mut arbitrary::Unstructured::new(&bytes)).unwrap(),
};

8
crates/optimism/primitives/src/transaction/signed.rs
View File

@@ -13,9 +13,7 @@ use alloy_eips::{
eip7702::SignedAuthorization,
};
use alloy_evm::{FromRecoveredTx, FromTxWithEncoded};
use alloy_primitives::{
keccak256, Address, Bytes, PrimitiveSignature as Signature, TxHash, TxKind, Uint, B256,
};
use alloy_primitives::{keccak256, Address, Bytes, Signature, TxHash, TxKind, Uint, B256};
use alloy_rlp::Header;
use core::{
hash::{Hash, Hasher},
@@ -650,7 +648,7 @@ impl<'a> arbitrary::Arbitrary<'a> for OpTransactionSigned {
let mut transaction = OpTypedTransaction::arbitrary(u)?;
let secp = secp256k1::Secp256k1::new();
let key_pair = secp256k1::Keypair::new(&secp, &mut rand::thread_rng());
let key_pair = secp256k1::Keypair::new(&secp, &mut rand_08::thread_rng());
let signature = reth_primitives_traits::crypto::secp256k1::sign_message(
B256::from_slice(&key_pair.secret_bytes()[..]),
signature_hash(&transaction),
@@ -730,7 +728,7 @@ pub mod serde_bincode_compat {
use alloy_consensus::transaction::serde_bincode_compat::{
TxEip1559, TxEip2930, TxEip7702, TxLegacy,
};
use alloy_primitives::{PrimitiveSignature as Signature, TxHash};
use alloy_primitives::{Signature, TxHash};
use reth_primitives_traits::{serde_bincode_compat::SerdeBincodeCompat, SignedTransaction};
use serde::{Deserialize, Serialize};

2
crates/optimism/rpc/src/eth/transaction.rs
View File

@@ -1,7 +1,7 @@
//! Loads and formats OP transaction RPC response.
use alloy_consensus::{transaction::Recovered, Transaction as _};
use alloy_primitives::{Bytes, PrimitiveSignature as Signature, Sealable, Sealed, B256};
use alloy_primitives::{Bytes, Sealable, Sealed, Signature, B256};
use alloy_rpc_types_eth::TransactionInfo;
use op_alloy_consensus::OpTxEnvelope;
use op_alloy_rpc_types::{OpTransactionRequest, Transaction};

2
crates/optimism/txpool/src/transaction.rs
View File

@@ -284,7 +284,7 @@ mod tests {
use crate::{OpPooledTransaction, OpTransactionValidator};
use alloy_consensus::transaction::Recovered;
use alloy_eips::eip2718::Encodable2718;
use alloy_primitives::{PrimitiveSignature as Signature, TxKind, U256};
use alloy_primitives::{Signature, TxKind, U256};
use op_alloy_consensus::{OpTypedTransaction, TxDeposit};
use reth_optimism_chainspec::OP_MAINNET;
use reth_optimism_primitives::OpTransactionSigned;

2
crates/primitives-traits/Cargo.toml
View File

@@ -66,6 +66,7 @@ byteorder.workspace = true
proptest-arbitrary-interop.workspace = true
proptest.workspace = true
rand.workspace = true
rand_08.workspace = true
serde.workspace = true
serde_json.workspace = true
test-fuzz.workspace = true
@@ -141,6 +142,7 @@ serde = [
"alloy-trie/serde",
"revm-bytecode/serde",
"revm-state/serde",
"rand_08/serde",
]
reth-codec = [
"dep:reth-codecs",

4
crates/primitives-traits/src/crypto.rs
View File

@@ -167,7 +167,7 @@ mod tests {
fn sanity_ecrecover_call_secp256k1() {
use super::impl_secp256k1::*;
let (secret, public) = secp256k1::generate_keypair(&mut rand::thread_rng());
let (secret, public) = secp256k1::generate_keypair(&mut rand_08::thread_rng());
let signer = public_key_to_address(public);
let message = b"hello world";
@@ -210,7 +210,7 @@ mod tests {
use super::{impl_k256, impl_secp256k1};
let (secp256k1_secret, secp256k1_public) =
secp256k1::generate_keypair(&mut rand::thread_rng());
secp256k1::generate_keypair(&mut rand_08::thread_rng());
let k256_secret = k256::ecdsa::SigningKey::from_slice(&secp256k1_secret.secret_bytes())
.expect("k256 secret");
let k256_public = *k256_secret.verifying_key();

2
crates/primitives-traits/src/header/sealed.rs
View File

@@ -325,7 +325,7 @@ pub(super) mod serde_bincode_compat {
}
let mut bytes = [0u8; 1024];
rand::thread_rng().fill(&mut bytes[..]);
rand::rng().fill(&mut bytes[..]);
let data = Data {
transaction: SealedHeader::arbitrary(&mut arbitrary::Unstructured::new(&bytes))
.unwrap(),

2
crates/primitives-traits/src/size.rs
View File

@@ -4,7 +4,7 @@ use alloy_consensus::{
TxEip4844WithSidecar, TxEip7702, TxLegacy, TxType,
};
use alloy_eips::eip4895::Withdrawals;
use alloy_primitives::{PrimitiveSignature as Signature, TxHash, B256};
use alloy_primitives::{Signature, TxHash, B256};
use revm_primitives::Log;
/// Trait for calculating a heuristic for the in-memory size of a struct.

4
crates/primitives-traits/src/transaction/signature.rs
View File

@@ -1,12 +1,12 @@
//! Signature types and helpers
/// Re-exported signature type
pub use alloy_primitives::PrimitiveSignature as Signature;
pub use alloy_primitives::Signature;
#[cfg(test)]
mod tests {
use crate::crypto::secp256k1::recover_signer;
use alloy_primitives::{address, PrimitiveSignature as Signature, B256, U256};
use alloy_primitives::{address, Signature, B256, U256};
use std::str::FromStr;
#[test]

2
crates/primitives-traits/src/transaction/signed.rs
View File

@@ -10,7 +10,7 @@ use alloy_consensus::{
EthereumTxEnvelope, SignableTransaction,
};
use alloy_eips::eip2718::{Decodable2718, Encodable2718};
use alloy_primitives::{keccak256, Address, PrimitiveSignature as Signature, TxHash, B256};
use alloy_primitives::{keccak256, Address, Signature, TxHash, B256};
use alloy_rlp::{Decodable, Encodable};
use core::hash::Hash;

3
crates/rpc/ipc/src/server/mod.rs
View File

@@ -792,7 +792,8 @@ impl<HttpMiddleware, RpcMiddleware> Builder<HttpMiddleware, RpcMiddleware> {
#[cfg(test)]
#[expect(missing_docs)]
pub fn dummy_name() -> String {
let num: u64 = rand::Rng::gen(&mut rand::thread_rng());
use rand::Rng;
let num: u64 = rand::rng().random();
if cfg!(windows) {
format!(r"\\.\pipe\my-pipe-{}", num)
} else {

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

@@ -52,7 +52,7 @@ fn payload_body_roundtrip() {
#[test]
fn payload_validation_conversion() {
let mut rng = generators::rng();
let parent = rng.gen();
let parent = rng.random();
let block = random_block(
&mut rng,
100,

2
crates/rpc/rpc-eth-api/src/helpers/signer.rs
View File

@@ -1,7 +1,7 @@
//! An abstraction over ethereum signers.
use alloy_dyn_abi::TypedData;
use alloy_primitives::{Address, PrimitiveSignature as Signature};
use alloy_primitives::{Address, Signature};
use alloy_rpc_types_eth::TransactionRequest;
use dyn_clone::DynClone;
use reth_rpc_eth_types::SignError;

2
crates/rpc/rpc/Cargo.toml
View File

@@ -83,7 +83,6 @@ parking_lot.workspace = true
tracing.workspace = true
tracing-futures.workspace = true
futures.workspace = true
rand.workspace = true
serde.workspace = true
thiserror.workspace = true
derive_more.workspace = true
@@ -95,6 +94,7 @@ reth-transaction-pool = { workspace = true, features = ["test-utils"] }
reth-provider = { workspace = true, features = ["test-utils"] }
alloy-consensus.workspace = true
rand.workspace = true
jsonrpsee-types.workspace = true
jsonrpsee = { workspace = true, features = ["client"] }

2
crates/rpc/rpc/src/debug.rs
View File

@@ -649,7 +649,7 @@ where
let state = state_provider
.witness(Default::default(), hashed_state)
.map_err(EthApiError::from)?;
Ok(ExecutionWitness { state, codes, keys })
Ok(ExecutionWitness { state, codes, keys, headers: vec![] })
})
.await
}

16
crates/rpc/rpc/src/eth/core.rs
View File

@@ -465,9 +465,10 @@ mod tests {
use crate::{EthApi, EthApiBuilder};
use alloy_consensus::{Block, BlockBody, Header};
use alloy_eips::BlockNumberOrTag;
use alloy_primitives::{PrimitiveSignature as Signature, B256, U64};
use alloy_primitives::{Signature, B256, U64};
use alloy_rpc_types::FeeHistory;
use jsonrpsee_types::error::INVALID_PARAMS_CODE;
use rand::Rng;
use reth_chain_state::CanonStateSubscriptions;
use reth_chainspec::{BaseFeeParams, ChainSpec, ChainSpecProvider};
use reth_ethereum_primitives::TransactionSigned;
@@ -476,7 +477,7 @@ mod tests {
use reth_provider::test_utils::{MockEthProvider, NoopProvider};
use reth_rpc_eth_api::EthApiServer;
use reth_storage_api::{BlockReader, BlockReaderIdExt, StateProviderFactory};
use reth_testing_utils::{generators, generators::Rng};
use reth_testing_utils::generators;
use reth_transaction_pool::test_utils::{testing_pool, TestPool};
fn build_test_eth_api<
@@ -519,11 +520,12 @@ mod tests {
let mut parent_hash = B256::default();
for i in (0..block_count).rev() {
let hash = rng.gen();
let hash = rng.random();
// Note: Generates saner values to avoid invalid overflows later
let gas_limit = rng.gen::<u32>() as u64;
let base_fee_per_gas: Option<u64> = rng.gen::<bool>().then(|| rng.gen::<u32>() as u64);
let gas_used = rng.gen::<u32>() as u64;
let gas_limit = rng.random::<u32>() as u64;
let base_fee_per_gas: Option<u64> =
rng.random::<bool>().then(|| rng.random::<u32>() as u64);
let gas_used = rng.random::<u32>() as u64;
let header = Header {
number: newest_block - i,
@@ -539,7 +541,7 @@ mod tests {
const TOTAL_TRANSACTIONS: usize = 100;
let mut transactions = Vec::with_capacity(TOTAL_TRANSACTIONS);
for _ in 0..TOTAL_TRANSACTIONS {
let random_fee: u128 = rng.gen();
let random_fee: u128 = rng.random();
if let Some(base_fee_per_gas) = header.base_fee_per_gas {
let transaction = TransactionSigned::new_unhashed(

6
crates/rpc/rpc/src/eth/filter.rs
View File

@@ -807,9 +807,9 @@ mod tests {
fn test_block_range_iter() {
let mut rng = generators::rng();
let start = rng.gen::<u32>() as u64;
let end = start.saturating_add(rng.gen::<u32>() as u64);
let step = rng.gen::<u16>() as u64;
let start = rng.random::<u32>() as u64;
let end = start.saturating_add(rng.random::<u32>() as u64);
let step = rng.random::<u16>() as u64;
let range = start..=end;
let mut iter = BlockRangeInclusiveIter::new(range.clone(), step);
let (from, mut end) = iter.next().unwrap();

4
crates/rpc/rpc/src/eth/helpers/signer.rs
View File

@@ -6,7 +6,7 @@ use crate::EthApi;
use alloy_dyn_abi::TypedData;
use alloy_eips::eip2718::Decodable2718;
use alloy_network::{eip2718::Encodable2718, EthereumWallet, TransactionBuilder};
use alloy_primitives::{eip191_hash_message, Address, PrimitiveSignature as Signature, B256};
use alloy_primitives::{eip191_hash_message, Address, Signature, B256};
use alloy_rpc_types_eth::TransactionRequest;
use alloy_signer::SignerSync;
use alloy_signer_local::PrivateKeySigner;
@@ -43,7 +43,7 @@ impl DevSigner {
pub fn random_signers<T: Decodable2718>(num: u32) -> Vec<Box<dyn EthSigner<T> + 'static>> {
let mut signers = Vec::with_capacity(num as usize);
for _ in 0..num {
let sk = PrivateKeySigner::random_with(&mut rand::thread_rng());
let sk = PrivateKeySigner::random();
let address = sk.address();
let addresses = vec![address];

2
crates/rpc/rpc/src/eth/helpers/types.rs
View File

@@ -2,7 +2,7 @@
use alloy_consensus::{Transaction as _, TxEnvelope};
use alloy_network::{Ethereum, Network};
use alloy_primitives::PrimitiveSignature as Signature;
use alloy_primitives::Signature;
use alloy_rpc_types::TransactionRequest;
use alloy_rpc_types_eth::{Transaction, TransactionInfo};
use reth_ethereum_primitives::TransactionSigned;

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

@@ -362,13 +362,14 @@ mod tests {
)?;
tx.put::<tables::Transactions>(next_tx_num, transaction.clone())?;
let (addr, _) =
accounts.get_mut(rng.gen::<usize>() % n_accounts as usize).unwrap();
let (addr, _) = accounts
.get_mut((rng.random::<u64>() % n_accounts) as usize)
.unwrap();
for _ in 0..2 {
let new_entry = StorageEntry {
key: keccak256([rng.gen::<u8>()]),
value: U256::from(rng.gen::<u8>() % 30 + 1),
key: keccak256([rng.random::<u8>()]),
value: U256::from(rng.random::<u8>() % 30 + 1),
};
self.insert_storage_entry(
tx,
@@ -384,14 +385,14 @@ mod tests {
)?;
// Randomize rewards
let has_reward: bool = rng.gen();
let has_reward: bool = rng.random();
if has_reward {
self.insert_storage_entry(
tx,
(block_number, Address::random()).into(),
StorageEntry {
key: keccak256("mining"),
value: U256::from(rng.gen::<u32>()),
value: U256::from(rng.random::<u32>()),
},
progress.number == stage_progress,
)?;

8
crates/stages/types/src/checkpoints.rs
View File

@@ -412,13 +412,13 @@ mod tests {
#[test]
fn merkle_checkpoint_roundtrip() {
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
let checkpoint = MerkleCheckpoint {
target_block: rng.gen(),
last_account_key: rng.gen(),
target_block: rng.random(),
last_account_key: rng.random(),
walker_stack: vec![StoredSubNode {
key: B256::random_with(&mut rng).to_vec(),
nibble: Some(rng.gen()),
nibble: Some(rng.random()),
node: None,
}],
state: HashBuilderState::default(),

2
crates/storage/codecs/derive/src/arbitrary.rs
View File

@@ -68,7 +68,7 @@ pub fn maybe_generate_tests(
// get random instance of type
let mut raw = vec![0u8; 1024];
rand::thread_rng().fill_bytes(&mut raw);
rand::rng().fill_bytes(&mut raw);
let mut unstructured = arbitrary::Unstructured::new(&raw[..]);
let val: Result<super::#type_ident, _> = arbitrary::Arbitrary::arbitrary(&mut unstructured);
if val.is_err() {

2
crates/storage/codecs/src/alloy/authorization_list.rs
View File

@@ -84,7 +84,7 @@ mod tests {
address: address!("0xdac17f958d2ee523a2206206994597c13d831ec7"),
nonce: 1,
}
.into_signed(alloy_primitives::PrimitiveSignature::new(
.into_signed(alloy_primitives::Signature::new(
b256!("0x1fd474b1f9404c0c5df43b7620119ffbc3a1c3f942c73b6e14e9f55255ed9b1d").into(),
b256!("0x29aca24813279a901ec13b5f7bb53385fa1fc627b946592221417ff74a49600d").into(),
false,

2
crates/storage/codecs/src/alloy/signature.rs
View File

@@ -1,7 +1,7 @@
//! Compact implementation for [`Signature`]
use crate::Compact;
use alloy_primitives::{PrimitiveSignature as Signature, U256};
use alloy_primitives::{Signature, U256};
impl Compact for Signature {
fn to_compact<B>(&self, buf: &mut B) -> usize

12
crates/storage/codecs/src/alloy/transaction/ethereum.rs
View File

@@ -3,7 +3,7 @@ use alloy_consensus::{
transaction::RlpEcdsaEncodableTx, EthereumTxEnvelope, Signed, Transaction, TxEip1559,
TxEip2930, TxEip7702, TxLegacy, TxType,
};
use alloy_primitives::PrimitiveSignature;
use alloy_primitives::Signature;
use bytes::{Buf, BufMut};
/// A trait for extracting transaction without type and signature and serializing it using
@@ -42,7 +42,7 @@ pub(super) trait FromTxCompact {
fn from_tx_compact(
buf: &[u8],
tx_type: Self::TxType,
signature: PrimitiveSignature,
signature: Signature,
) -> (Self, &[u8])
where
Self: Sized;
@@ -66,7 +66,7 @@ impl<Eip4844: Compact + Transaction> FromTxCompact for EthereumTxEnvelope<Eip484
fn from_tx_compact(
buf: &[u8],
tx_type: TxType,
signature: PrimitiveSignature,
signature: Signature,
) -> (Self, &[u8]) {
match tx_type {
TxType::Legacy => {
@@ -99,14 +99,14 @@ impl<Eip4844: Compact + Transaction> FromTxCompact for EthereumTxEnvelope<Eip484
}
pub(super) trait Envelope: FromTxCompact<TxType: Compact> {
fn signature(&self) -> &PrimitiveSignature;
fn signature(&self) -> &Signature;
fn tx_type(&self) -> Self::TxType;
}
impl<Eip4844: Compact + Transaction + RlpEcdsaEncodableTx> Envelope
for EthereumTxEnvelope<Eip4844>
{
fn signature(&self) -> &PrimitiveSignature {
fn signature(&self) -> &Signature {
Self::signature(self)
}
@@ -184,7 +184,7 @@ impl<T: Envelope + ToTxCompact + Transaction + Send + Sync> CompactEnvelope for
let tx_bits = (flags & 0b110) >> 1;
let zstd_bit = flags >> 3;
let (signature, buf) = PrimitiveSignature::from_compact(buf, sig_bit);
let (signature, buf) = Signature::from_compact(buf, sig_bit);
let (tx_type, buf) = T::TxType::from_compact(buf, tx_bits);
let (transaction, buf) = if zstd_bit != 0 {

Some files were not shown because too many files have changed in this diff Show More