diff --git a/account_manager/src/main.rs b/account_manager/src/main.rs index ae3823049d..095f65cbc5 100644 --- a/account_manager/src/main.rs +++ b/account_manager/src/main.rs @@ -130,7 +130,6 @@ fn main() { log, "The account manager must be run with a subcommand. See help for more information." ); - return; } } } diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index 731165f81f..a0fe864742 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -125,6 +125,8 @@ pub struct BeaconChain { log: Logger, } +type BeaconInfo = (BeaconBlock, BeaconState); + impl BeaconChain { /// Instantiate a new Beacon Chain, from genesis. pub fn from_genesis( @@ -1060,7 +1062,7 @@ impl BeaconChain { if block.slot <= finalized_slot { return Ok(BlockProcessingOutcome::WouldRevertFinalizedSlot { block_slot: block.slot, - finalized_slot: finalized_slot, + finalized_slot, }); } @@ -1258,7 +1260,7 @@ impl BeaconChain { &self, randao_reveal: Signature, slot: Slot, - ) -> Result<(BeaconBlock, BeaconState), BlockProductionError> { + ) -> Result, BlockProductionError> { let state = self .state_at_slot(slot - 1) .map_err(|_| BlockProductionError::UnableToProduceAtSlot(slot))?; @@ -1279,7 +1281,7 @@ impl BeaconChain { mut state: BeaconState, produce_at_slot: Slot, randao_reveal: Signature, - ) -> Result<(BeaconBlock, BeaconState), BlockProductionError> { + ) -> Result, BlockProductionError> { metrics::inc_counter(&metrics::BLOCK_PRODUCTION_REQUESTS); let timer = metrics::start_timer(&metrics::BLOCK_PRODUCTION_TIMES); @@ -1457,7 +1459,7 @@ impl BeaconChain { // End fork choice metrics timer. metrics::stop_timer(timer); - if let Err(_) = result { + if result.is_err() { metrics::inc_counter(&metrics::FORK_CHOICE_ERRORS); } diff --git a/beacon_node/beacon_chain/src/beacon_chain_builder.rs b/beacon_node/beacon_chain/src/beacon_chain_builder.rs index 357644a2d5..949fb856b8 100644 --- a/beacon_node/beacon_chain/src/beacon_chain_builder.rs +++ b/beacon_node/beacon_chain/src/beacon_chain_builder.rs @@ -137,7 +137,7 @@ impl BeaconChainBuilder { BuildStrategy::LoadFromStore => { BeaconChain::from_store(store, eth1_backend, event_handler, self.spec, self.log) .map_err(|e| format!("Error loading BeaconChain from database: {:?}", e))? - .ok_or_else(|| format!("Unable to find exising BeaconChain in database."))? + .ok_or_else(|| "Unable to find exising BeaconChain in database.".to_string())? } BuildStrategy::FromGenesis { genesis_block, diff --git a/beacon_node/beacon_chain/src/metrics.rs b/beacon_node/beacon_chain/src/metrics.rs index 6efa4b3f2b..5fa5d4807a 100644 --- a/beacon_node/beacon_chain/src/metrics.rs +++ b/beacon_node/beacon_chain/src/metrics.rs @@ -228,10 +228,7 @@ fn scrape_head_state(state: &BeaconState, state ); set_gauge_by_usize(&HEAD_STATE_SHARDS, state.previous_crosslinks.len()); set_gauge_by_usize(&HEAD_STATE_TOTAL_VALIDATORS, state.validators.len()); - set_gauge_by_u64( - &HEAD_STATE_VALIDATOR_BALANCES, - state.balances.iter().fold(0_u64, |acc, i| acc + i), - ); + set_gauge_by_u64(&HEAD_STATE_VALIDATOR_BALANCES, state.balances.iter().sum()); set_gauge_by_usize( &HEAD_STATE_ACTIVE_VALIDATORS, state diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs index 97b802ddfe..8efbefe84c 100644 --- a/beacon_node/beacon_chain/src/test_utils.rs +++ b/beacon_node/beacon_chain/src/test_utils.rs @@ -21,7 +21,7 @@ pub use types::test_utils::generate_deterministic_keypairs; pub use crate::persisted_beacon_chain::{PersistedBeaconChain, BEACON_CHAIN_DB_KEY}; -pub const HARNESS_GENESIS_TIME: u64 = 1567552690; // 4th September 2019 +pub const HARNESS_GENESIS_TIME: u64 = 1_567_552_690; // 4th September 2019 /// Indicates how the `BeaconChainHarness` should produce blocks. #[derive(Clone, Copy, Debug)] diff --git a/beacon_node/client/src/lib.rs b/beacon_node/client/src/lib.rs index fc5e9f8602..a92a60e2be 100644 --- a/beacon_node/client/src/lib.rs +++ b/beacon_node/client/src/lib.rs @@ -12,6 +12,7 @@ use beacon_chain::{ use exit_future::Signal; use futures::{future::Future, Stream}; use network::Service as NetworkService; +use rest_api::NetworkInfo; use slog::{crit, error, info, o}; use slot_clock::SlotClock; use std::marker::PhantomData; @@ -231,12 +232,15 @@ where // Start the `rest_api` service let api_exit_signal = if client_config.rest_api.enabled { + let network_info = NetworkInfo { + network_service: network.clone(), + network_chan: network_send.clone(), + }; match rest_api::start_server( &client_config.rest_api, executor, beacon_chain.clone(), - network.clone(), - network_send.clone(), + network_info, client_config.db_path().expect("unable to read datadir"), eth2_config.clone(), &log, diff --git a/beacon_node/rest_api/src/helpers.rs b/beacon_node/rest_api/src/helpers.rs index a711246b0d..45eda8b705 100644 --- a/beacon_node/rest_api/src/helpers.rs +++ b/beacon_node/rest_api/src/helpers.rs @@ -68,11 +68,11 @@ pub fn parse_pubkey(string: &str) -> Result { let pubkey = PublicKey::from_bytes(pubkey_bytes.as_slice()).map_err(|e| { ApiError::BadRequest(format!("Unable to deserialize public key: {:?}.", e)) })?; - return Ok(pubkey); + Ok(pubkey) } else { - return Err(ApiError::BadRequest( + Err(ApiError::BadRequest( "Public key must have a '0x' prefix".to_string(), - )); + )) } } diff --git a/beacon_node/rest_api/src/lib.rs b/beacon_node/rest_api/src/lib.rs index 133fc3a266..4f9bcc6171 100644 --- a/beacon_node/rest_api/src/lib.rs +++ b/beacon_node/rest_api/src/lib.rs @@ -48,6 +48,11 @@ pub struct ApiService { eth2_config: Arc, } +pub struct NetworkInfo { + pub network_service: Arc>, + pub network_chan: mpsc::UnboundedSender, +} + fn into_boxfut(item: F) -> BoxFut where F: IntoFuture, Error = ApiError>, @@ -194,8 +199,7 @@ pub fn start_server( config: &ApiConfig, executor: &TaskExecutor, beacon_chain: Arc>, - network_service: Arc>, - network_chan: mpsc::UnboundedSender, + network_info: NetworkInfo, db_path: PathBuf, eth2_config: Eth2Config, log: &slog::Logger, @@ -226,8 +230,8 @@ pub fn start_server( log: server_log.clone(), beacon_chain: server_bc.clone(), db_path: db_path.clone(), - network_service: network_service.clone(), - network_channel: Arc::new(RwLock::new(network_chan.clone())), + network_service: network_info.network_service.clone(), + network_channel: Arc::new(RwLock::new(network_info.network_chan.clone())), eth2_config: eth2_config.clone(), }) }; diff --git a/beacon_node/rest_api/src/response_builder.rs b/beacon_node/rest_api/src/response_builder.rs index d5b530f8ab..ec7d8cb8db 100644 --- a/beacon_node/rest_api/src/response_builder.rs +++ b/beacon_node/rest_api/src/response_builder.rs @@ -27,7 +27,7 @@ impl ResponseBuilder { e )) }) - .map(|h| String::from(h))?; + .map(String::from)?; // JSON is our default encoding, unless something else is requested. let encoding = match content_header { @@ -85,7 +85,7 @@ impl ResponseBuilder { Response::builder() .status(StatusCode::OK) .header("content-type", content_type) - .body(Body::from(body)) + .body(body) .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e))) } diff --git a/beacon_node/rest_api/src/validator.rs b/beacon_node/rest_api/src/validator.rs index 60c0eed060..082966637a 100644 --- a/beacon_node/rest_api/src/validator.rs +++ b/beacon_node/rest_api/src/validator.rs @@ -190,7 +190,7 @@ pub fn get_new_beacon_block(req: Request) - /// HTTP Handler to publish a BeaconBlock, which has been signed by a validator. pub fn publish_beacon_block(req: Request) -> BoxFut { - let _ = try_future!(check_content_type_for_json(&req)); + try_future!(check_content_type_for_json(&req)); let log = get_logger_from_request(&req); let beacon_chain = try_future!(get_beacon_chain_from_request::(&req)); // Get the network sending channel from the request, for later transmission @@ -268,9 +268,12 @@ pub fn get_new_attestation(req: Request) -> .map_err(|e| { ApiError::ServerError(format!("Unable to read validator index cache. {:?}", e)) })? - .ok_or(ApiError::BadRequest( - "The provided validator public key does not correspond to a validator index.".into(), - ))?; + .ok_or_else(|| { + ApiError::BadRequest( + "The provided validator public key does not correspond to a validator index." + .into(), + ) + })?; // Build cache for the requested epoch head_state @@ -286,7 +289,7 @@ pub fn get_new_attestation(req: Request) -> e )) })? - .ok_or(ApiError::BadRequest("No validator duties could be found for the requested validator. Cannot provide valid attestation.".into()))?; + .ok_or_else(|| ApiError::BadRequest("No validator duties could be found for the requested validator. Cannot provide valid attestation.".into()))?; // Check that we are requesting an attestation during the slot where it is relevant. let present_slot = beacon_chain.slot().map_err(|e| ApiError::ServerError( @@ -354,7 +357,7 @@ pub fn get_new_attestation(req: Request) -> /// HTTP Handler to publish an Attestation, which has been signed by a validator. pub fn publish_attestation(req: Request) -> BoxFut { - let _ = try_future!(check_content_type_for_json(&req)); + try_future!(check_content_type_for_json(&req)); let log = get_logger_from_request(&req); let beacon_chain = try_future!(get_beacon_chain_from_request::(&req)); // Get the network sending channel from the request, for later transmission diff --git a/beacon_node/rpc/src/attestation.rs b/beacon_node/rpc/src/attestation.rs index f4b49049ae..aea7119aad 100644 --- a/beacon_node/rpc/src/attestation.rs +++ b/beacon_node/rpc/src/attestation.rs @@ -118,7 +118,7 @@ impl AttestationService for AttestationServiceInstance { self.network_chan .try_send(NetworkMessage::Publish { topics: vec![topic], - message: message, + message, }) .unwrap_or_else(|e| { error!( diff --git a/beacon_node/rpc/src/beacon_block.rs b/beacon_node/rpc/src/beacon_block.rs index 346d7e263e..e9e7490cac 100644 --- a/beacon_node/rpc/src/beacon_block.rs +++ b/beacon_node/rpc/src/beacon_block.rs @@ -121,7 +121,7 @@ impl BeaconBlockService for BeaconBlockServiceInstance { self.network_chan .try_send(NetworkMessage::Publish { topics: vec![topic], - message: message, + message, }) .unwrap_or_else(|e| { error!( diff --git a/beacon_node/src/config.rs b/beacon_node/src/config.rs index 5cfb45287b..58de096d12 100644 --- a/beacon_node/src/config.rs +++ b/beacon_node/src/config.rs @@ -233,7 +233,7 @@ impl ConfigBuilder { // directory onto it. let data_dir: PathBuf = cli_args .value_of("datadir") - .map(|string| PathBuf::from(string)) + .map(PathBuf::from) .or_else(|| { dirs::home_dir().map(|mut home| { home.push(DEFAULT_DATA_DIR); @@ -528,9 +528,9 @@ impl ConfigBuilder { .parse::() .map_err(|e| format!("Unable to parse default listen address: {:?}", e))?; - self.client_config.network.listen_address = addr.clone().into(); - self.client_config.rpc.listen_address = addr.clone(); - self.client_config.rest_api.listen_address = addr.clone(); + self.client_config.network.listen_address = addr.into(); + self.client_config.rpc.listen_address = addr; + self.client_config.rest_api.listen_address = addr; Ok(()) } @@ -557,8 +557,8 @@ impl ConfigBuilder { if self.eth2_config.spec_constants != self.client_config.spec_constants { crit!(self.log, "Specification constants do not match."; - "client_config" => format!("{}", self.client_config.spec_constants), - "eth2_config" => format!("{}", self.eth2_config.spec_constants) + "client_config" => self.client_config.spec_constants.to_string(), + "eth2_config" => self.eth2_config.spec_constants.to_string() ); return Err("Specification constant mismatch".into()); } diff --git a/beacon_node/store/src/iter.rs b/beacon_node/store/src/iter.rs index c97241903f..678cd26f11 100644 --- a/beacon_node/store/src/iter.rs +++ b/beacon_node/store/src/iter.rs @@ -214,7 +214,7 @@ mod test { state_a.slot = Slot::from(slots_per_historical_root); state_b.slot = Slot::from(slots_per_historical_root * 2); - let mut hashes = (0..).into_iter().map(|i| Hash256::from_low_u64_be(i)); + let mut hashes = (0..).map(Hash256::from_low_u64_be); for root in &mut state_a.block_roots[..] { *root = hashes.next().unwrap() @@ -230,7 +230,7 @@ mod test { let iter = BlockRootsIterator::new(store.clone(), &state_b); assert!( - iter.clone().find(|(_root, slot)| *slot == 0).is_some(), + iter.clone().any(|(_root, slot)| slot == 0), "iter should contain zero slot" ); @@ -241,8 +241,8 @@ mod test { assert_eq!(collected.len(), expected_len); - for i in 0..expected_len { - assert_eq!(collected[i].0, Hash256::from_low_u64_be(i as u64)); + for (i, item) in collected.iter().enumerate() { + assert_eq!(item.0, Hash256::from_low_u64_be(i as u64)); } } @@ -257,17 +257,17 @@ mod test { state_a.slot = Slot::from(slots_per_historical_root); state_b.slot = Slot::from(slots_per_historical_root * 2); - let mut hashes = (0..).into_iter().map(|i| Hash256::from_low_u64_be(i)); + let mut hashes = (0..).map(Hash256::from_low_u64_be); for slot in 0..slots_per_historical_root { state_a .set_state_root(Slot::from(slot), hashes.next().unwrap()) - .expect(&format!("should set state_a slot {}", slot)); + .unwrap_or_else(|_| panic!("should set state_a slot {}", slot)); } for slot in slots_per_historical_root..slots_per_historical_root * 2 { state_b .set_state_root(Slot::from(slot), hashes.next().unwrap()) - .expect(&format!("should set state_b slot {}", slot)); + .unwrap_or_else(|_| panic!("should set state_b slot {}", slot)); } let state_a_root = Hash256::from_low_u64_be(slots_per_historical_root as u64); @@ -279,7 +279,7 @@ mod test { let iter = StateRootsIterator::new(store.clone(), &state_b); assert!( - iter.clone().find(|(_root, slot)| *slot == 0).is_some(), + iter.clone().any(|(_root, slot)| slot == 0), "iter should contain zero slot" ); @@ -290,8 +290,8 @@ mod test { assert_eq!(collected.len(), expected_len, "collection length incorrect"); - for i in 0..expected_len { - let (hash, slot) = collected[i]; + for (i, item) in collected.iter().enumerate() { + let (hash, slot) = *item; assert_eq!(slot, i as u64, "slot mismatch at {}: {} vs {}", i, slot, i); diff --git a/beacon_node/store/src/metrics.rs b/beacon_node/store/src/metrics.rs index 90237824d2..6f51c71ba3 100644 --- a/beacon_node/store/src/metrics.rs +++ b/beacon_node/store/src/metrics.rs @@ -94,7 +94,7 @@ pub fn scrape_for_metrics(db_path: &PathBuf) { let db_size = if let Ok(iter) = fs::read_dir(db_path) { iter.filter_map(std::result::Result::ok) .map(size_of_dir_entry) - .fold(0_u64, |sum, val| sum + val) + .sum() } else { 0 }; diff --git a/eth2/lmd_ghost/src/reduced_tree.rs b/eth2/lmd_ghost/src/reduced_tree.rs index 73fab13bfd..b786887f11 100644 --- a/eth2/lmd_ghost/src/reduced_tree.rs +++ b/eth2/lmd_ghost/src/reduced_tree.rs @@ -246,7 +246,7 @@ where pub fn latest_message(&self, validator_index: usize) -> Option<(Hash256, Slot)> { match self.latest_votes.get_ref(validator_index) { - Some(Some(v)) => Some((v.hash.clone(), v.slot.clone())), + Some(Some(v)) => Some((v.hash, v.slot)), _ => None, } } diff --git a/eth2/state_processing/benches/benches.rs b/eth2/state_processing/benches/benches.rs index bdbe57b8ed..c277e6734f 100644 --- a/eth2/state_processing/benches/benches.rs +++ b/eth2/state_processing/benches/benches.rs @@ -71,6 +71,7 @@ fn get_worst_block( builder.build(&spec) } +#[allow(clippy::unit_arg)] fn bench_block( c: &mut Criterion, block: BeaconBlock, diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs index f352acee11..fec16c5b95 100644 --- a/eth2/state_processing/src/per_block_processing.rs +++ b/eth2/state_processing/src/per_block_processing.rs @@ -59,8 +59,8 @@ pub enum VerifySignatures { } impl VerifySignatures { - pub fn is_true(&self) -> bool { - *self == VerifySignatures::True + pub fn is_true(self) -> bool { + self == VerifySignatures::True } } diff --git a/eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs b/eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs index 54a48d7b7a..194c2b018e 100644 --- a/eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs +++ b/eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs @@ -45,7 +45,7 @@ pub fn is_valid_indexed_attestation( let check_sorted = |list: &[u64]| -> Result<()> { list.windows(2).enumerate().try_for_each(|(i, pair)| { if pair[0] >= pair[1] { - return Err(error(Invalid::BadValidatorIndicesOrdering(i))); + Err(error(Invalid::BadValidatorIndicesOrdering(i))) } else { Ok(()) } diff --git a/eth2/state_processing/src/per_block_processing/tests.rs b/eth2/state_processing/src/per_block_processing/tests.rs index f419d5fae7..31704de44c 100644 --- a/eth2/state_processing/src/per_block_processing/tests.rs +++ b/eth2/state_processing/src/per_block_processing/tests.rs @@ -31,8 +31,8 @@ fn invalid_block_header_state_slot() { let builder = get_builder(&spec); let (mut block, mut state) = builder.build(None, None, &spec); - state.slot = Slot::new(133713); - block.slot = Slot::new(424242); + state.slot = Slot::new(133_713); + block.slot = Slot::new(424_242); let result = per_block_processing( &mut state, diff --git a/eth2/state_processing/src/per_block_processing/verify_attestation.rs b/eth2/state_processing/src/per_block_processing/verify_attestation.rs index e2f8821a92..4384409010 100644 --- a/eth2/state_processing/src/per_block_processing/verify_attestation.rs +++ b/eth2/state_processing/src/per_block_processing/verify_attestation.rs @@ -130,6 +130,6 @@ fn verify_casper_ffg_vote<'a, T: EthSpec>( ); Ok(state.get_previous_crosslink(data.crosslink.shard)?) } else { - return Err(error(Invalid::BadTargetEpoch)); + Err(error(Invalid::BadTargetEpoch)) } } diff --git a/eth2/state_processing/src/test_utils.rs b/eth2/state_processing/src/test_utils.rs index 1d0ca3f930..ce06a4fbb4 100644 --- a/eth2/state_processing/src/test_utils.rs +++ b/eth2/state_processing/src/test_utils.rs @@ -70,7 +70,7 @@ impl BlockBuilder { builder.set_parent_root(parent_root); // Used as a stream of validator indices for use in slashings, exits, etc. - let mut validators_iter = (0..keypairs.len() as u64).into_iter(); + let mut validators_iter = 0..keypairs.len() as u64; // Insert `ProposerSlashing` objects. for _ in 0..self.num_proposer_slashings { @@ -171,7 +171,7 @@ impl BlockBuilder { info!("Inserted {} transfers.", builder.block.body.transfers.len()); // Set the eth1 data to be different from the state. - self.block_builder.block.body.eth1_data.block_hash = Hash256::from_slice(&vec![42; 32]); + self.block_builder.block.body.eth1_data.block_hash = Hash256::from_slice(&[42; 32]); let block = self .block_builder diff --git a/eth2/types/src/beacon_state/committee_cache/tests.rs b/eth2/types/src/beacon_state/committee_cache/tests.rs index 4c17d3f96c..a2acae6e2d 100644 --- a/eth2/types/src/beacon_state/committee_cache/tests.rs +++ b/eth2/types/src/beacon_state/committee_cache/tests.rs @@ -73,7 +73,6 @@ fn shuffles_for_the_right_epoch() { let spec = &MinimalEthSpec::default_spec(); let distinct_hashes: Vec = (0..MinimalEthSpec::epochs_per_historical_vector()) - .into_iter() .map(|i| Hash256::from_low_u64_be(i as u64)) .collect(); diff --git a/eth2/types/src/beacon_state/tests.rs b/eth2/types/src/beacon_state/tests.rs index 0363e5848d..708f23fd58 100644 --- a/eth2/types/src/beacon_state/tests.rs +++ b/eth2/types/src/beacon_state/tests.rs @@ -192,7 +192,7 @@ fn tree_hash_cache() { assert_eq!(root.as_bytes(), &state.tree_hash_root()[..]); - state.slot = state.slot + 1; + state.slot += 1; let root = state.update_tree_hash_cache().unwrap(); assert_eq!(root.as_bytes(), &state.tree_hash_root()[..]); @@ -231,9 +231,8 @@ mod committees { shuffle_list(active_indices, spec.shuffle_round_count, &seed[..], false).unwrap(); let mut expected_indices_iter = shuffling.iter(); - let mut expected_shards_iter = (0..T::ShardCount::to_u64()) - .into_iter() - .map(|i| (start_shard + i) % T::ShardCount::to_u64()); + let mut expected_shards_iter = + (0..T::ShardCount::to_u64()).map(|i| (start_shard + i) % T::ShardCount::to_u64()); // Loop through all slots in the epoch being tested. for slot in epoch.slot_iter(T::slots_per_epoch()) { @@ -306,7 +305,6 @@ mod committees { let (mut state, _keypairs): (BeaconState, _) = builder.build(); let distinct_hashes: Vec = (0..T::epochs_per_historical_vector()) - .into_iter() .map(|i| Hash256::from_low_u64_be(i as u64)) .collect(); state.randao_mixes = FixedVector::from(distinct_hashes); diff --git a/eth2/types/src/test_utils/builders/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/builders/testing_beacon_state_builder.rs index cf8c9ec8ea..2f4dde7e63 100644 --- a/eth2/types/src/test_utils/builders/testing_beacon_state_builder.rs +++ b/eth2/types/src/test_utils/builders/testing_beacon_state_builder.rs @@ -123,7 +123,7 @@ impl TestingBeaconStateBuilder { .collect::>() .into(); - let genesis_time = 1567052589; // 29 August, 2019; + let genesis_time = 1_567_052_589; // 29 August, 2019; let mut state = BeaconState::new( genesis_time, diff --git a/eth2/types/src/utils/serde_utils.rs b/eth2/types/src/utils/serde_utils.rs index a9b27d75b5..a9b75079cf 100644 --- a/eth2/types/src/utils/serde_utils.rs +++ b/eth2/types/src/utils/serde_utils.rs @@ -46,6 +46,7 @@ where Ok(array) } +#[allow(clippy::trivially_copy_pass_by_ref)] pub fn fork_to_hex_str(bytes: &[u8; FORK_BYTES_LEN], serializer: S) -> Result where S: Serializer, diff --git a/eth2/utils/bls/src/secret_key.rs b/eth2/utils/bls/src/secret_key.rs index 54da0fa0f3..d9ada73337 100644 --- a/eth2/utils/bls/src/secret_key.rs +++ b/eth2/utils/bls/src/secret_key.rs @@ -80,8 +80,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let original = - SecretKey::from_bytes("jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj".as_bytes()) - .unwrap(); + SecretKey::from_bytes(b"jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj").unwrap(); let bytes = ssz_encode(&original); let decoded = SecretKey::from_ssz_bytes(&bytes).unwrap(); diff --git a/eth2/utils/eth2_interop_keypairs/src/lib.rs b/eth2/utils/eth2_interop_keypairs/src/lib.rs index cac7e74621..6fa303553b 100644 --- a/eth2/utils/eth2_interop_keypairs/src/lib.rs +++ b/eth2/utils/eth2_interop_keypairs/src/lib.rs @@ -58,10 +58,12 @@ pub fn be_private_key(validator_index: usize) -> [u8; PRIVATE_KEY_BYTES] { /// Return a public and private keypair for a given `validator_index`. pub fn keypair(validator_index: usize) -> Keypair { - let sk = SecretKey::from_bytes(&be_private_key(validator_index)).expect(&format!( - "Should build valid private key for validator index {}", - validator_index - )); + let sk = SecretKey::from_bytes(&be_private_key(validator_index)).unwrap_or_else(|_| { + panic!( + "Should build valid private key for validator index {}", + validator_index + ) + }); Keypair { pk: PublicKey::from_secret_key(&sk), diff --git a/eth2/utils/eth2_interop_keypairs/tests/generation.rs b/eth2/utils/eth2_interop_keypairs/tests/generation.rs index 0d89eaa4dc..dfc6a9b410 100644 --- a/eth2/utils/eth2_interop_keypairs/tests/generation.rs +++ b/eth2/utils/eth2_interop_keypairs/tests/generation.rs @@ -19,14 +19,11 @@ fn reference_private_keys() { "2908643403277969554503670470854573663206729491025062456164283925661321952518", "19554639423851580804889717218680781396599791537051606512605582393920758869044", ]; - reference - .into_iter() - .enumerate() - .for_each(|(i, reference)| { - let bytes = be_private_key(i); - let num = BigUint::from_bytes_be(&bytes); - assert_eq!(&num.to_str_radix(10), reference) - }); + reference.iter().enumerate().for_each(|(i, reference)| { + let bytes = be_private_key(i); + let num = BigUint::from_bytes_be(&bytes); + assert_eq!(&num.to_str_radix(10), reference) + }); } #[test] @@ -46,19 +43,16 @@ fn reference_public_keys() { "ptMQ27+rmiJFD1mZP4ekzl22Ij87Xx8w0sTscYki1ADgs8d0HejlmWD3JBGg7hCn", "mJNBPAAoOj+e2f2YRd2hzqOCKNIlZ/lUHczDV+VKLWpuIEEDySVky8BfSQWsfEk6", ]; - reference - .into_iter() - .enumerate() - .for_each(|(i, reference)| { - let pair = keypair(i); - let reference = base64::decode(reference).expect("Reference should be valid base64"); + reference.iter().enumerate().for_each(|(i, reference)| { + let pair = keypair(i); + let reference = base64::decode(reference).expect("Reference should be valid base64"); - assert_eq!( - reference.len(), - 48, - "Reference should be 48 bytes (public key size)" - ); + assert_eq!( + reference.len(), + 48, + "Reference should be 48 bytes (public key size)" + ); - assert_eq!(pair.pk.as_bytes(), reference); - }); + assert_eq!(pair.pk.as_bytes(), reference); + }); } diff --git a/eth2/utils/lighthouse_metrics/src/lib.rs b/eth2/utils/lighthouse_metrics/src/lib.rs index 9022a5b684..225bb460b6 100644 --- a/eth2/utils/lighthouse_metrics/src/lib.rs +++ b/eth2/utils/lighthouse_metrics/src/lib.rs @@ -100,7 +100,9 @@ pub fn start_timer(histogram: &Result) -> Option { /// Stops a timer created with `start_timer(..)`. pub fn stop_timer(timer: Option) { - timer.map(|t| t.observe_duration()); + if let Some(t) = timer { + t.observe_duration() + } } pub fn inc_counter(counter: &Result) { diff --git a/eth2/utils/merkle_proof/src/lib.rs b/eth2/utils/merkle_proof/src/lib.rs index 73a972c759..13f67c5840 100644 --- a/eth2/utils/merkle_proof/src/lib.rs +++ b/eth2/utils/merkle_proof/src/lib.rs @@ -21,7 +21,7 @@ lazy_static! { /// Zero nodes to act as "synthetic" left and right subtrees of other zero nodes. static ref ZERO_NODES: Vec = { - (0..MAX_TREE_DEPTH + 1).map(MerkleTree::Zero).collect() + (0..=MAX_TREE_DEPTH).map(MerkleTree::Zero).collect() }; } @@ -205,7 +205,7 @@ mod tests { let merkle_tree = MerkleTree::create(&leaves, depth); let merkle_root = merkle_tree.hash(); - let proofs_ok = (0..leaves.len()).into_iter().all(|i| { + let proofs_ok = (0..leaves.len()).all(|i| { let (leaf, branch) = merkle_tree.generate_proof(i, depth); leaf == leaves[i] && verify_merkle_proof(leaf, &branch, depth, i, merkle_root) }); diff --git a/eth2/utils/ssz/examples/large_list.rs b/eth2/utils/ssz/examples/large_list.rs index 618603604e..a1b10ab7a3 100644 --- a/eth2/utils/ssz/examples/large_list.rs +++ b/eth2/utils/ssz/examples/large_list.rs @@ -8,7 +8,6 @@ fn main() { let vec: Vec = vec![4242; 8196]; let output: Vec> = (0..40_000) - .into_iter() .map(|_| Vec::from_ssz_bytes(&vec.as_ssz_bytes()).unwrap()) .collect(); diff --git a/eth2/utils/ssz/examples/large_list_of_structs.rs b/eth2/utils/ssz/examples/large_list_of_structs.rs index 2924541ea6..2aaaf9b8a5 100644 --- a/eth2/utils/ssz/examples/large_list_of_structs.rs +++ b/eth2/utils/ssz/examples/large_list_of_structs.rs @@ -24,7 +24,6 @@ fn main() { let vec: Vec = vec![fixed_len; 8196]; let output: Vec> = (0..40_000) - .into_iter() .map(|_| Vec::from_ssz_bytes(&vec.as_ssz_bytes()).unwrap()) .collect(); diff --git a/eth2/utils/ssz/examples/struct_definition.rs b/eth2/utils/ssz/examples/struct_definition.rs index 0971e21da9..123da12c58 100644 --- a/eth2/utils/ssz/examples/struct_definition.rs +++ b/eth2/utils/ssz/examples/struct_definition.rs @@ -57,7 +57,7 @@ impl Decode for Foo { } fn main() { - let foo = Foo { + let my_foo = Foo { a: 42, b: vec![0, 1, 2, 3], c: 11, @@ -65,9 +65,9 @@ fn main() { let bytes = vec![42, 0, 8, 0, 0, 0, 11, 0, 0, 1, 2, 3]; - assert_eq!(foo.as_ssz_bytes(), bytes); + assert_eq!(my_foo.as_ssz_bytes(), bytes); let decoded_foo = Foo::from_ssz_bytes(&bytes).unwrap(); - assert_eq!(foo, decoded_foo); + assert_eq!(my_foo, decoded_foo); } diff --git a/eth2/utils/ssz/src/encode/impls.rs b/eth2/utils/ssz/src/encode/impls.rs index d25e79370e..6622168771 100644 --- a/eth2/utils/ssz/src/encode/impls.rs +++ b/eth2/utils/ssz/src/encode/impls.rs @@ -239,7 +239,7 @@ impl Encode for Vec { if ::is_ssz_fixed_len() { ::ssz_fixed_len() * self.len() } else { - let mut len = self.into_iter().map(|item| item.ssz_bytes_len()).sum(); + let mut len = self.iter().map(|item| item.ssz_bytes_len()).sum(); len += BYTES_PER_LENGTH_OFFSET * self.len(); len } diff --git a/lcli/src/parse_hex.rs b/lcli/src/parse_hex.rs index 50f61ea9f2..7f2f7f90ff 100644 --- a/lcli/src/parse_hex.rs +++ b/lcli/src/parse_hex.rs @@ -21,7 +21,7 @@ pub fn run_parse_hex(matches: &ArgMatches) -> Result<(), String> { info!("Using minimal spec"); info!("Type: {:?}", type_str); - match type_str.as_ref() { + match type_str { "block" => decode_and_print::>(&hex)?, "state" => decode_and_print::>(&hex)?, other => return Err(format!("Unknown type: {}", other)), diff --git a/tests/ef_tests/src/cases/ssz_generic.rs b/tests/ef_tests/src/cases/ssz_generic.rs index fc62e66fc0..442dd6e096 100644 --- a/tests/ef_tests/src/cases/ssz_generic.rs +++ b/tests/ef_tests/src/cases/ssz_generic.rs @@ -222,15 +222,12 @@ fn ssz_generic_test(path: &Path) -> Result<(), Error> { } } // Invalid - else { - if let Ok(decoded) = T::from_ssz_bytes(&serialized) { - return Err(Error::DidntFail(format!( - "Decoded invalid bytes into: {:?}", - decoded - ))); - } + else if let Ok(decoded) = T::from_ssz_bytes(&serialized) { + return Err(Error::DidntFail(format!( + "Decoded invalid bytes into: {:?}", + decoded + ))); } - Ok(()) } @@ -291,11 +288,11 @@ where let decoded: Vec = hex::decode(&s.as_str()[2..]).map_err(D::Error::custom)?; if decoded.len() > N::to_usize() { - return Err(D::Error::custom(format!( + Err(D::Error::custom(format!( "Too many values for list, got: {}, limit: {}", decoded.len(), N::to_usize() - ))); + ))) } else { Ok(decoded.into()) } diff --git a/validator_client/src/config.rs b/validator_client/src/config.rs index 33e8addb62..d1d04722bc 100644 --- a/validator_client/src/config.rs +++ b/validator_client/src/config.rs @@ -171,17 +171,17 @@ impl Config { .map_err(|e| format!("Unable to deserialize private key: {:?}", e))?; let ki = key.identifier(); - if &ki - != &path + if ki + != path .file_name() .ok_or_else(|| "Invalid path".to_string())? .to_string_lossy() { - return Err(format!( + Err(format!( "The validator key ({:?}) did not match the directory filename {:?}.", ki, path.to_str() - )); + )) } else { Ok(key) } @@ -219,10 +219,7 @@ impl Config { &self, range: std::ops::Range, ) -> Result, String> { - Ok(range - .into_iter() - .map(generate_deterministic_keypair) - .collect()) + Ok(range.map(generate_deterministic_keypair).collect()) } /// Loads the keypairs according to `self.key_source`. Will return one or more keypairs, or an diff --git a/validator_client/src/duties/epoch_duties.rs b/validator_client/src/duties/epoch_duties.rs index 692a8d6a62..c8f2b981a9 100644 --- a/validator_client/src/duties/epoch_duties.rs +++ b/validator_client/src/duties/epoch_duties.rs @@ -118,14 +118,14 @@ impl EpochDutiesMap { if let Some(epoch_duty) = epoch_duties.get(signer) { if let Some(duty) = epoch_duty { // Retrieves the duty for a validator at a given slot - return Ok(duty.is_work_slot(slot)); + Ok(duty.is_work_slot(slot)) } else { // the validator isn't active - return Ok(None); + Ok(None) } } else { // validator isn't known - return Err(EpochDutiesMapError::UnknownValidator); + Err(EpochDutiesMapError::UnknownValidator) } } }