Fix Rust beta compiler errors 1.78.0-beta.1 (#5439)

* remove redundant imports

* fix test

* contains key

* fmt

* Merge branch 'unstable' into fix-beta-compiler

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -72,7 +72,7 @@ use crate::{
     kzg_utils, metrics, AvailabilityPendingExecutedBlock, BeaconChainError, BeaconForkChoiceStore,
     BeaconSnapshot, CachedHead,
 };
-use eth2::types::{EventKind, SseBlobSidecar, SseBlock, SseExtendedPayloadAttributes, SyncDuty};
+use eth2::types::{EventKind, SseBlobSidecar, SseBlock, SseExtendedPayloadAttributes};
 use execution_layer::{
     BlockProposalContents, BlockProposalContentsType, BuilderParams, ChainHealth, ExecutionLayer,
     FailedCondition, PayloadAttributes, PayloadStatus,
@@ -120,8 +120,7 @@ use store::{
 use task_executor::{ShutdownReason, TaskExecutor};
 use tokio_stream::Stream;
 use tree_hash::TreeHash;
-use types::beacon_state::CloneConfig;
+use types::blob_sidecar::FixedBlobSidecarList;
-use types::blob_sidecar::{BlobSidecarList, FixedBlobSidecarList};
 use types::payload::BlockProductionVersion;
 use types::*;
 

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -780,7 +780,7 @@ mod test {
     use store::{HotColdDB, ItemStore, LevelDB, StoreConfig};
     use tempfile::{tempdir, TempDir};
     use types::non_zero_usize::new_non_zero_usize;
-    use types::{ChainSpec, ExecPayload, MinimalEthSpec};
+    use types::{ExecPayload, MinimalEthSpec};
 
     const LOW_VALIDATOR_COUNT: usize = 32;
 

beacon_node/beacon_chain/src/early_attester_cache.rs

@@ -6,7 +6,6 @@ use crate::{
 use parking_lot::RwLock;
 use proto_array::Block as ProtoBlock;
 use std::sync::Arc;
-use types::blob_sidecar::BlobSidecarList;
 use types::*;
 
 pub struct CacheItem<E: EthSpec> {

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -9,7 +9,6 @@ use ssz_derive::{Decode, Encode};
 use state_processing::per_block_processing::get_new_eth1_data;
 use std::cmp::Ordering;
 use std::collections::HashMap;
-use std::iter::DoubleEndedIterator;
 use std::marker::PhantomData;
 use std::time::{SystemTime, UNIX_EPOCH};
 use store::{DBColumn, Error as StoreError, StoreItem};
@@ -736,7 +735,7 @@ mod test {
     mod eth1_chain_json_backend {
         use super::*;
         use eth1::DepositLog;
-        use types::{test_utils::generate_deterministic_keypair, EthSpec, MainnetEthSpec};
+        use types::{test_utils::generate_deterministic_keypair, MainnetEthSpec};
 
         fn get_eth1_chain() -> Eth1Chain<CachingEth1Backend<E>, E> {
             let eth1_config = Eth1Config {

beacon_node/beacon_chain/src/observed_blob_sidecars.rs

@@ -111,7 +111,7 @@ mod tests {
     use super::*;
     use bls::Hash256;
     use std::sync::Arc;
-    use types::{BlobSidecar, MainnetEthSpec};
+    use types::MainnetEthSpec;
 
     type E = MainnetEthSpec;
 

beacon_node/beacon_chain/src/snapshot_cache.rs

@@ -367,10 +367,7 @@ impl<T: EthSpec> SnapshotCache<T> {
 mod test {
     use super::*;
     use crate::test_utils::{BeaconChainHarness, EphemeralHarnessType};
-    use types::{
+    use types::{test_utils::generate_deterministic_keypair, BeaconBlock, MainnetEthSpec};
-        test_utils::generate_deterministic_keypair, BeaconBlock, Epoch, MainnetEthSpec,
-        SignedBeaconBlock, Slot,
-    };
 
     fn get_harness() -> BeaconChainHarness<EphemeralHarnessType<MainnetEthSpec>> {
         let harness = BeaconChainHarness::builder(MainnetEthSpec)

beacon_node/beacon_chain/src/test_utils.rs

@@ -61,7 +61,6 @@ use task_executor::TaskExecutor;
 use task_executor::{test_utils::TestRuntime, ShutdownReason};
 use tree_hash::TreeHash;
 use types::payload::BlockProductionVersion;
-use types::sync_selection_proof::SyncSelectionProof;
 pub use types::test_utils::generate_deterministic_keypairs;
 use types::test_utils::TestRandom;
 use types::{typenum::U4294967296, *};

beacon_node/beacon_chain/src/validator_monitor.rs

@@ -15,7 +15,6 @@ use state_processing::per_epoch_processing::{
     errors::EpochProcessingError, EpochProcessingSummary,
 };
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
 use std::io;
 use std::marker::PhantomData;
 use std::str::Utf8Error;

beacon_node/beacon_chain/src/validator_pubkey_cache.rs

@@ -2,7 +2,6 @@ use crate::errors::BeaconChainError;
 use crate::{BeaconChainTypes, BeaconStore};
 use ssz::{Decode, Encode};
 use std::collections::HashMap;
-use std::convert::TryInto;
 use std::marker::PhantomData;
 use store::{DBColumn, Error as StoreError, StoreItem, StoreOp};
 use types::{BeaconState, Hash256, PublicKey, PublicKeyBytes};
@@ -195,7 +194,7 @@ mod test {
     use logging::test_logger;
     use std::sync::Arc;
     use store::HotColdDB;
-    use types::{BeaconState, EthSpec, Keypair, MainnetEthSpec};
+    use types::{EthSpec, Keypair, MainnetEthSpec};
 
     type E = MainnetEthSpec;
     type T = EphemeralHarnessType<E>;

beacon_node/beacon_processor/src/work_reprocessing_queue.rs

@@ -964,7 +964,6 @@ impl<S: SlotClock> ReprocessQueue<S> {
 mod tests {
     use super::*;
     use slot_clock::TestingSlotClock;
-    use types::Slot;
 
     #[test]
     fn backfill_processing_schedule_calculation() {

beacon_node/client/src/config.rs

@@ -118,7 +118,7 @@ impl Default for Config {
 impl Config {
     /// Updates the data directory for the Client.
     pub fn set_data_dir(&mut self, data_dir: PathBuf) {
-        self.data_dir = data_dir.clone();
+        self.data_dir.clone_from(&data_dir);
         self.http_api.data_dir = data_dir;
     }
 

beacon_node/eth1/src/block_cache.rs

@@ -196,7 +196,6 @@ impl BlockCache {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use types::Hash256;
 
     fn get_block(i: u64, interval_secs: u64) -> Eth1Block {
         Eth1Block {

beacon_node/eth1/tests/test.rs

@@ -99,7 +99,6 @@ async fn new_anvil_instance() -> Result<AnvilEth1Instance, String> {
 
 mod eth1_cache {
     use super::*;
-    use types::{EthSpec, MainnetEthSpec};
 
     #[tokio::test]
     async fn simple_scenario() {

beacon_node/execution_layer/src/engine_api.rs

@@ -17,7 +17,6 @@ pub use json_structures::{JsonWithdrawal, TransitionConfigurationV1};
 use pretty_reqwest_error::PrettyReqwestError;
 use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
-use std::convert::TryFrom;
 use strum::IntoStaticStr;
 use superstruct::superstruct;
 pub use types::{

beacon_node/execution_layer/src/engine_api/http.rs

@@ -11,7 +11,6 @@ use std::collections::HashSet;
 use tokio::sync::Mutex;
 
 use std::time::{Duration, Instant};
-use types::EthSpec;
 
 pub use deposit_log::{DepositLog, Log};
 pub use reqwest::Client;
@@ -1191,7 +1190,7 @@ mod test {
     use std::future::Future;
     use std::str::FromStr;
     use std::sync::Arc;
-    use types::{ExecutionPayloadMerge, MainnetEthSpec, Transactions, Unsigned, VariableList};
+    use types::{MainnetEthSpec, Unsigned};
 
     struct Tester {
         server: MockServer<MainnetEthSpec>,

beacon_node/execution_layer/src/engine_api/json_structures.rs

@@ -4,10 +4,7 @@ use strum::EnumString;
 use superstruct::superstruct;
 use types::beacon_block_body::KzgCommitments;
 use types::blob_sidecar::BlobsList;
-use types::{
+use types::{FixedVector, Unsigned};
-    EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadDeneb,
-    ExecutionPayloadMerge, FixedVector, Transactions, Unsigned, VariableList, Withdrawal,
-};
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]

beacon_node/execution_layer/src/test_utils/handle_rpc.rs

@@ -5,7 +5,6 @@ use crate::test_utils::DEFAULT_MOCK_EL_PAYLOAD_VALUE_WEI;
 use serde::{de::DeserializeOwned, Deserialize};
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
-use types::{EthSpec, ForkName};
 
 pub const GENERIC_ERROR_CODE: i64 = -1234;
 pub const BAD_PARAMS_ERROR_CODE: i64 = -32602;

beacon_node/execution_layer/src/test_utils/mock_builder.rs

@@ -71,8 +71,6 @@ pub trait BidStuff<E: EthSpec> {
     fn set_withdrawals_root(&mut self, withdrawals_root: Hash256);
 
     fn sign_builder_message(&mut self, sk: &SecretKey, spec: &ChainSpec) -> Signature;
-
-    fn to_signed_bid(self, signature: Signature) -> SignedBuilderBid<E>;
 }
 
 impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
@@ -183,13 +181,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
         let message = self.signing_root(domain);
         sk.sign(message)
     }
-
-    fn to_signed_bid(self, signature: Signature) -> SignedBuilderBid<E> {
-        SignedBuilderBid {
-            message: self,
-            signature,
-        }
-    }
 }
 
 #[derive(Clone)]

beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs

@@ -2,14 +2,12 @@ use crate::{
     test_utils::{
         MockServer, DEFAULT_JWT_SECRET, DEFAULT_TERMINAL_BLOCK, DEFAULT_TERMINAL_DIFFICULTY,
     },
-    Config, *,
+    *,
 };
 use keccak_hash::H256;
 use kzg::Kzg;
-use sensitive_url::SensitiveUrl;
-use task_executor::TaskExecutor;
 use tempfile::NamedTempFile;
-use types::{Address, ChainSpec, Epoch, EthSpec, Hash256, MainnetEthSpec};
+use types::MainnetEthSpec;
 
 pub struct MockExecutionLayer<T: EthSpec> {
     pub server: MockServer<T>,

beacon_node/genesis/src/interop.rs

@@ -137,7 +137,7 @@ pub fn interop_genesis_state_with_withdrawal_credentials<T: EthSpec>(
 #[cfg(test)]
 mod test {
     use super::*;
-    use types::{test_utils::generate_deterministic_keypairs, EthSpec, MinimalEthSpec};
+    use types::{test_utils::generate_deterministic_keypairs, MinimalEthSpec};
 
     type TestEthSpec = MinimalEthSpec;
 

beacon_node/http_api/src/block_packing_efficiency.rs

@@ -132,7 +132,7 @@ impl<T: EthSpec> PackingEfficiencyHandler<T> {
         }
 
         // Remove duplicate attestations as these yield no reward.
-        attestations_in_block.retain(|x, _| self.included_attestations.get(x).is_none());
+        attestations_in_block.retain(|x, _| !self.included_attestations.contains_key(x));
         self.included_attestations
             .extend(attestations_in_block.clone());
 
@@ -179,8 +179,9 @@ impl<T: EthSpec> PackingEfficiencyHandler<T> {
                 .collect::<Vec<_>>()
         };
 
-        self.committee_store.previous_epoch_committees =
+        self.committee_store
-            self.committee_store.current_epoch_committees.clone();
+            .previous_epoch_committees
+            .clone_from(&self.committee_store.current_epoch_committees);
 
         self.committee_store.current_epoch_committees = new_committees;
 

beacon_node/lighthouse_network/src/gossipsub/behaviour.rs

@@ -525,7 +525,7 @@ where
             return Err(SubscriptionError::NotAllowed);
         }
 
-        if self.mesh.get(&topic_hash).is_some() {
+        if self.mesh.contains_key(&topic_hash) {
             tracing::debug!(%topic, "Topic is already in the mesh");
             return Ok(false);
         }
@@ -551,7 +551,7 @@ where
         tracing::debug!(%topic, "Unsubscribing from topic");
         let topic_hash = topic.hash();
 
-        if self.mesh.get(&topic_hash).is_none() {
+        if !self.mesh.contains_key(&topic_hash) {
             tracing::debug!(topic=%topic_hash, "Already unsubscribed from topic");
             // we are not subscribed
             return Ok(false);

beacon_node/lighthouse_network/src/gossipsub/behaviour/tests.rs

@@ -22,18 +22,13 @@
 
 use super::*;
 use crate::gossipsub::subscription_filter::WhitelistSubscriptionFilter;
-use crate::gossipsub::transform::{DataTransform, IdentityTransform};
+use crate::gossipsub::types::RpcReceiver;
-use crate::gossipsub::types::{RpcOut, RpcReceiver};
+use crate::gossipsub::{config::ConfigBuilder, types::Rpc, IdentTopic as Topic};
-use crate::gossipsub::ValidationError;
-use crate::gossipsub::{
-    config::Config, config::ConfigBuilder, types::Rpc, IdentTopic as Topic, TopicScoreParams,
-};
 use async_std::net::Ipv4Addr;
 use byteorder::{BigEndian, ByteOrder};
-use libp2p::core::{ConnectedPoint, Endpoint};
+use libp2p::core::ConnectedPoint;
 use rand::Rng;
 use std::thread::sleep;
-use std::time::Duration;
 
 #[derive(Default, Debug)]
 struct InjectNodes<D, F>
@@ -427,7 +422,7 @@ fn test_subscribe() {
         .create_network();
 
     assert!(
-        gs.mesh.get(&topic_hashes[0]).is_some(),
+        gs.mesh.contains_key(&topic_hashes[0]),
         "Subscribe should add a new entry to the mesh[topic] hashmap"
     );
 
@@ -477,7 +472,7 @@ fn test_unsubscribe() {
             "Topic_peers contain a topic entry"
         );
         assert!(
-            gs.mesh.get(topic_hash).is_some(),
+            gs.mesh.contains_key(topic_hash),
             "mesh should contain a topic entry"
         );
     }
@@ -511,7 +506,7 @@ fn test_unsubscribe() {
     // check we clean up internal structures
     for topic_hash in &topic_hashes {
         assert!(
-            gs.mesh.get(topic_hash).is_none(),
+            !gs.mesh.contains_key(topic_hash),
             "All topics should have been removed from the mesh"
         );
     }
@@ -694,7 +689,7 @@ fn test_publish_without_flood_publishing() {
         .create_network();
 
     assert!(
-        gs.mesh.get(&topic_hashes[0]).is_some(),
+        gs.mesh.contains_key(&topic_hashes[0]),
         "Subscribe should add a new entry to the mesh[topic] hashmap"
     );
 
@@ -774,7 +769,7 @@ fn test_fanout() {
         .create_network();
 
     assert!(
-        gs.mesh.get(&topic_hashes[0]).is_some(),
+        gs.mesh.contains_key(&topic_hashes[0]),
         "Subscribe should add a new entry to the mesh[topic] hashmap"
     );
     // Unsubscribe from topic
@@ -946,7 +941,7 @@ fn test_handle_received_subscriptions() {
     );
 
     assert!(
-        gs.connected_peers.get(&unknown_peer).is_none(),
+        !gs.connected_peers.contains_key(&unknown_peer),
         "Unknown peer should not have been added"
     );
 
@@ -1347,7 +1342,7 @@ fn test_handle_graft_multiple_topics() {
     }
 
     assert!(
-        gs.mesh.get(&topic_hashes[2]).is_none(),
+        !gs.mesh.contains_key(&topic_hashes[2]),
         "Expected the second topic to not be in the mesh"
     );
 }
@@ -5228,7 +5223,7 @@ fn test_graft_without_subscribe() {
         .create_network();
 
     assert!(
-        gs.mesh.get(&topic_hashes[0]).is_some(),
+        gs.mesh.contains_key(&topic_hashes[0]),
         "Subscribe should add a new entry to the mesh[topic] hashmap"
     );
 

beacon_node/lighthouse_network/src/gossipsub/config.rs

@@ -903,10 +903,8 @@ impl std::fmt::Debug for Config {
 mod test {
     use super::*;
     use crate::gossipsub::topic::IdentityHash;
-    use crate::gossipsub::types::PeerKind;
     use crate::gossipsub::Topic;
     use libp2p::core::UpgradeInfo;
-    use libp2p::swarm::StreamProtocol;
     use std::collections::hash_map::DefaultHasher;
     use std::hash::{Hash, Hasher};
 

beacon_node/lighthouse_network/src/gossipsub/mcache.rs

@@ -221,9 +221,7 @@ impl MessageCache {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::gossipsub::types::RawMessage;
+    use crate::IdentTopic as Topic;
-    use crate::{IdentTopic as Topic, TopicHash};
-    use libp2p::identity::PeerId;
 
     fn gen_testm(x: u64, topic: TopicHash) -> (MessageId, RawMessage) {
         let default_id = |message: &RawMessage| {

beacon_node/lighthouse_network/src/gossipsub/peer_score.rs

@@ -102,7 +102,7 @@ impl PeerStats {
         topic_hash: TopicHash,
         params: &PeerScoreParams,
     ) -> Option<&mut TopicStats> {
-        if params.topics.get(&topic_hash).is_some() {
+        if params.topics.contains_key(&topic_hash) {
             Some(self.topics.entry(topic_hash).or_default())
         } else {
             self.topics.get_mut(&topic_hash)
@@ -310,7 +310,7 @@ impl PeerScore {
 
         // P6: IP collocation factor
         for ip in peer_stats.known_ips.iter() {
-            if self.params.ip_colocation_factor_whitelist.get(ip).is_some() {
+            if self.params.ip_colocation_factor_whitelist.contains(ip) {
                 continue;
             }
 
@@ -705,7 +705,7 @@ impl PeerScore {
     ) {
         let record = self.deliveries.entry(msg_id.clone()).or_default();
 
-        if record.peers.get(from).is_some() {
+        if record.peers.contains(from) {
             // we have already seen this duplicate!
             return;
         }

beacon_node/lighthouse_network/src/gossipsub/protocol.rs

@@ -30,7 +30,6 @@ use super::ValidationError;
 use asynchronous_codec::{Decoder, Encoder, Framed};
 use byteorder::{BigEndian, ByteOrder};
 use bytes::BytesMut;
-use futures::future;
 use futures::prelude::*;
 use libp2p::core::{InboundUpgrade, OutboundUpgrade, UpgradeInfo};
 use libp2p::identity::{PeerId, PublicKey};
@@ -508,10 +507,8 @@ impl Decoder for GossipsubCodec {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::gossipsub::config::Config;
+    use crate::gossipsub::IdentTopic as Topic;
-    use crate::gossipsub::protocol::{BytesMut, GossipsubCodec, HandlerEvent};
     use crate::gossipsub::*;
-    use crate::gossipsub::{IdentTopic as Topic, Version};
     use libp2p::identity::Keypair;
     use quickcheck::*;
 

beacon_node/lighthouse_network/src/gossipsub/subscription_filter.rs

@@ -212,7 +212,6 @@ impl TopicSubscriptionFilter for RegexSubscriptionFilter {
 mod test {
     use super::*;
     use crate::gossipsub::types::SubscriptionAction::*;
-    use std::iter::FromIterator;
 
     #[test]
     fn test_filter_incoming_allow_all_with_duplicates() {

beacon_node/lighthouse_network/src/peer_manager/peerdb.rs

@@ -1251,7 +1251,6 @@ impl BannedPeersCount {
 mod tests {
     use super::*;
     use libp2p::core::multiaddr::Protocol;
-    use libp2p::core::Multiaddr;
     use slog::{o, Drain};
     use std::net::{Ipv4Addr, Ipv6Addr};
     use types::MinimalEthSpec;

beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs

@@ -3,7 +3,7 @@ use crate::rpc::{
     codec::base::OutboundCodec,
     protocol::{Encoding, ProtocolId, RPCError, SupportedProtocol, ERROR_TYPE_MAX, ERROR_TYPE_MIN},
 };
-use crate::rpc::{InboundRequest, OutboundRequest, RPCCodedResponse, RPCResponse};
+use crate::rpc::{InboundRequest, OutboundRequest};
 use libp2p::bytes::BytesMut;
 use snap::read::FrameDecoder;
 use snap::write::FrameEncoder;
@@ -676,22 +676,13 @@ fn context_bytes_to_fork_name(
 mod tests {
 
     use super::*;
-    use crate::rpc::{protocol::*, MetaData};
+    use crate::rpc::protocol::*;
-    use crate::{
+    use crate::types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield};
-        rpc::{methods::StatusMessage, Ping, RPCResponseErrorCode},
-        types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield},
-    };
-    use std::sync::Arc;
     use types::{
         blob_sidecar::BlobIdentifier, BeaconBlock, BeaconBlockAltair, BeaconBlockBase,
-        BeaconBlockMerge, ChainSpec, EmptyBlock, Epoch, ForkContext, FullPayload, Hash256,
+        BeaconBlockMerge, EmptyBlock, Epoch, FullPayload, Signature, Slot,
-        Signature, SignedBeaconBlock, Slot,
     };
 
-    use snap::write::FrameEncoder;
-    use ssz::Encode;
-    use std::io::Write;
-
     type Spec = types::MainnetEthSpec;
 
     fn fork_context(fork_name: ForkName) -> ForkContext {

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -9,7 +9,7 @@ use crate::rpc::outbound::{OutboundFramed, OutboundRequest};
 use crate::rpc::protocol::InboundFramed;
 use fnv::FnvHashMap;
 use futures::prelude::*;
-use futures::{Sink, SinkExt};
+use futures::SinkExt;
 use libp2p::swarm::handler::{
     ConnectionEvent, ConnectionHandler, ConnectionHandlerEvent, DialUpgradeError,
     FullyNegotiatedInbound, FullyNegotiatedOutbound, StreamUpgradeError, SubstreamProtocol,

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -6,6 +6,7 @@ use serde::Serialize;
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
 use ssz_types::{typenum::U256, VariableList};
+use std::fmt::Display;
 use std::marker::PhantomData;
 use std::ops::Deref;
 use std::sync::Arc;
@@ -44,11 +45,13 @@ impl Deref for ErrorType {
     }
 }
 
-impl ToString for ErrorType {
+impl Display for ErrorType {
-    fn to_string(&self) -> String {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         #[allow(clippy::invalid_regex)]
         let re = Regex::new("\\p{C}").expect("Regex is valid");
-        String::from_utf8_lossy(&re.replace_all(self.0.deref(), &b""[..])).to_string()
+        let error_type_str =
+            String::from_utf8_lossy(&re.replace_all(self.0.deref(), &b""[..])).to_string();
+        write!(f, "{}", error_type_str)
     }
 }
 
@@ -580,7 +583,7 @@ impl<T: EthSpec> std::fmt::Display for RPCCodedResponse<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             RPCCodedResponse::Success(res) => write!(f, "{}", res),
-            RPCCodedResponse::Error(code, err) => write!(f, "{}: {}", code, err.to_string()),
+            RPCCodedResponse::Error(code, err) => write!(f, "{}: {}", code, err),
             RPCCodedResponse::StreamTermination(_) => write!(f, "Stream Termination"),
         }
     }

beacon_node/lighthouse_network/src/rpc/outbound.rs

@@ -2,11 +2,10 @@ use super::methods::*;
 use super::protocol::ProtocolId;
 use super::protocol::SupportedProtocol;
 use super::RPCError;
-use crate::rpc::protocol::Encoding;
+use crate::rpc::codec::{
-use crate::rpc::{
+    base::BaseOutboundCodec, ssz_snappy::SSZSnappyOutboundCodec, OutboundCodec,
-    codec::{base::BaseOutboundCodec, ssz_snappy::SSZSnappyOutboundCodec, OutboundCodec},
-    methods::ResponseTermination,
 };
+use crate::rpc::protocol::Encoding;
 use futures::future::BoxFuture;
 use futures::prelude::{AsyncRead, AsyncWrite};
 use futures::{FutureExt, SinkExt};

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -1,8 +1,5 @@
 use super::methods::*;
-use crate::rpc::{
+use crate::rpc::codec::{base::BaseInboundCodec, ssz_snappy::SSZSnappyInboundCodec, InboundCodec};
-    codec::{base::BaseInboundCodec, ssz_snappy::SSZSnappyInboundCodec, InboundCodec},
-    methods::{MaxErrorLen, ResponseTermination, MAX_ERROR_LEN},
-};
 use futures::future::BoxFuture;
 use futures::prelude::{AsyncRead, AsyncWrite};
 use futures::{FutureExt, StreamExt};

beacon_node/lighthouse_network/src/rpc/rate_limiter.rs

@@ -3,7 +3,6 @@ use crate::rpc::Protocol;
 use fnv::FnvHashMap;
 use libp2p::PeerId;
 use serde::{Deserialize, Serialize};
-use std::convert::TryInto;
 use std::future::Future;
 use std::hash::Hash;
 use std::pin::Pin;

beacon_node/lighthouse_network/src/service/gossip_cache.rs

@@ -268,8 +268,6 @@ impl futures::stream::Stream for GossipCache {
 
 #[cfg(test)]
 mod tests {
-    use crate::types::GossipKind;
-
     use super::*;
     use futures::stream::StreamExt;
 

beacon_node/lighthouse_network/src/types/pubsub.rs

@@ -5,7 +5,6 @@ use crate::types::{GossipEncoding, GossipKind, GossipTopic};
 use crate::TopicHash;
 use snap::raw::{decompress_len, Decoder, Encoder};
 use ssz::{Decode, Encode};
-use std::boxed::Box;
 use std::io::{Error, ErrorKind};
 use std::sync::Arc;
 use types::{

beacon_node/network/src/network_beacon_processor/rpc_methods.rs

@@ -6,7 +6,6 @@ use beacon_chain::{BeaconChainError, BeaconChainTypes, HistoricalBlockError, Whe
 use beacon_processor::SendOnDrop;
 use itertools::process_results;
 use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
-use lighthouse_network::rpc::StatusMessage;
 use lighthouse_network::rpc::*;
 use lighthouse_network::{PeerId, PeerRequestId, ReportSource, Response, SyncInfo};
 use slog::{debug, error, warn};

beacon_node/network/src/persisted_dht.rs

@@ -60,11 +60,10 @@ impl StoreItem for PersistedDht {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use lighthouse_network::Enr;
     use sloggers::{null::NullLoggerBuilder, Build};
     use std::str::FromStr;
     use store::config::StoreConfig;
-    use store::{HotColdDB, MemoryStore};
+    use store::MemoryStore;
     use types::{ChainSpec, MinimalEthSpec};
     #[test]
     fn test_persisted_dht() {

beacon_node/network/src/sync/block_lookups/single_block_lookup.rs

@@ -519,7 +519,6 @@ impl slog::Value for SingleLookupRequestState {
 mod tests {
     use super::*;
     use crate::sync::block_lookups::common::LookupType;
-    use crate::sync::block_lookups::common::{Lookup, RequestState};
     use beacon_chain::builder::Witness;
     use beacon_chain::eth1_chain::CachingEth1Backend;
     use sloggers::null::NullLoggerBuilder;
@@ -529,7 +528,7 @@ mod tests {
     use store::{HotColdDB, MemoryStore, StoreConfig};
     use types::{
         test_utils::{SeedableRng, TestRandom, XorShiftRng},
-        ChainSpec, EthSpec, MinimalEthSpec as E, SignedBeaconBlock, Slot,
+        ChainSpec, MinimalEthSpec as E, SignedBeaconBlock, Slot,
     };
 
     fn rand_block() -> SignedBeaconBlock<E> {

beacon_node/network/src/sync/block_lookups/tests.rs

@@ -1154,9 +1154,7 @@ fn test_same_chain_race_condition() {
 
 mod deneb_only {
     use super::*;
-    use crate::sync::block_lookups::common::ResponseType;
     use beacon_chain::data_availability_checker::AvailabilityCheckError;
-    use beacon_chain::test_utils::NumBlobs;
     use ssz_types::VariableList;
     use std::ops::IndexMut;
     use std::str::FromStr;

beacon_node/network/src/sync/manager.rs

@@ -57,7 +57,6 @@ use lighthouse_network::types::{NetworkGlobals, SyncState};
 use lighthouse_network::SyncInfo;
 use lighthouse_network::{PeerAction, PeerId};
 use slog::{crit, debug, error, info, trace, warn, Logger};
-use std::boxed::Box;
 use std::ops::IndexMut;
 use std::ops::Sub;
 use std::sync::Arc;

beacon_node/network/src/sync/range_sync/range.rs

@@ -395,10 +395,9 @@ mod tests {
     use slog::{o, Drain};
     use slot_clock::TestingSlotClock;
     use std::collections::HashSet;
-    use std::sync::Arc;
     use store::MemoryStore;
     use tokio::sync::mpsc;
-    use types::{ForkName, Hash256, MinimalEthSpec as E};
+    use types::{ForkName, MinimalEthSpec as E};
 
     #[derive(Debug)]
     struct FakeStorage {

beacon_node/operation_pool/src/max_cover.rs

@@ -118,7 +118,6 @@ where
 #[cfg(test)]
 mod test {
     use super::*;
-    use std::iter::FromIterator;
     use std::{collections::HashSet, hash::Hash};
 
     impl<T> MaxCover for HashSet<T>

beacon_node/src/config.rs

@@ -345,7 +345,9 @@ pub fn get_config<E: EthSpec>(
             clap_utils::parse_optional(cli_args, "suggested-fee-recipient")?;
         el_config.jwt_id = clap_utils::parse_optional(cli_args, "execution-jwt-id")?;
         el_config.jwt_version = clap_utils::parse_optional(cli_args, "execution-jwt-version")?;
-        el_config.default_datadir = client_config.data_dir().clone();
+        el_config
+            .default_datadir
+            .clone_from(client_config.data_dir());
         let execution_timeout_multiplier =
             clap_utils::parse_required(cli_args, "execution-timeout-multiplier")?;
         el_config.execution_timeout_multiplier = Some(execution_timeout_multiplier);

beacon_node/store/src/chunked_vector.rs

@@ -17,7 +17,6 @@
 use self::UpdatePattern::*;
 use crate::*;
 use ssz::{Decode, Encode};
-use typenum::Unsigned;
 use types::historical_summary::HistoricalSummary;
 
 /// Description of how a `BeaconState` field is updated during state processing.

beacon_node/store/src/hot_cold_store.rs

@@ -33,13 +33,11 @@ use state_processing::{
     BlockProcessingError, BlockReplayer, SlotProcessingError, StateProcessingStrategy,
 };
 use std::cmp::min;
-use std::convert::TryInto;
 use std::marker::PhantomData;
 use std::num::NonZeroUsize;
 use std::path::Path;
 use std::sync::Arc;
 use std::time::Duration;
-use types::blob_sidecar::BlobSidecarList;
 use types::*;
 
 /// On-disk database that stores finalized states efficiently.

beacon_node/store/src/impls/beacon_state.rs

@@ -1,8 +1,6 @@
 use crate::*;
 use ssz::{DecodeError, Encode};
 use ssz_derive::Encode;
-use std::convert::TryInto;
-use types::beacon_state::{CloneConfig, CommitteeCache, CACHED_EPOCHS};
 
 pub fn store_full_state<E: EthSpec>(
     state_root: &Hash256,

beacon_node/store/src/iter.rs

@@ -381,7 +381,6 @@ fn slot_of_prev_restore_point<E: EthSpec>(current_slot: Slot) -> Slot {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::HotColdDB;
     use crate::StoreConfig as Config;
     use beacon_chain::test_utils::BeaconChainHarness;
     use beacon_chain::types::{ChainSpec, MainnetEthSpec};

beacon_node/store/src/leveldb_store.rs

@@ -1,6 +1,5 @@
 use super::*;
 use crate::hot_cold_store::HotColdDBError;
-use crate::metrics;
 use leveldb::compaction::Compaction;
 use leveldb::database::batch::{Batch, Writebatch};
 use leveldb::database::kv::KV;
@@ -8,7 +7,7 @@ use leveldb::database::Database;
 use leveldb::error::Error as LevelDBError;
 use leveldb::iterator::{Iterable, KeyIterator, LevelDBIterator};
 use leveldb::options::{Options, ReadOptions, WriteOptions};
-use parking_lot::{Mutex, MutexGuard};
+use parking_lot::Mutex;
 use std::marker::PhantomData;
 use std::path::Path;
 

beacon_node/store/src/partial_beacon_state.rs

@@ -5,7 +5,6 @@ use crate::chunked_vector::{
 use crate::{get_key_for_col, DBColumn, Error, KeyValueStore, KeyValueStoreOp};
 use ssz::{Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
-use std::convert::TryInto;
 use std::sync::Arc;
 use types::historical_summary::HistoricalSummary;
 use types::superstruct;

common/deposit_contract/src/lib.rs

@@ -86,8 +86,8 @@ pub fn decode_eth1_tx_data(
 mod tests {
     use super::*;
     use types::{
-        test_utils::generate_deterministic_keypair, ChainSpec, EthSpec, Hash256, Keypair,
+        test_utils::generate_deterministic_keypair, ChainSpec, EthSpec, Keypair, MinimalEthSpec,
-        MinimalEthSpec, Signature,
+        Signature,
     };
 
     type E = MinimalEthSpec;

common/eth2/src/lib.rs

@@ -29,10 +29,8 @@ pub use reqwest::{StatusCode, Url};
 pub use sensitive_url::{SensitiveError, SensitiveUrl};
 use serde::{de::DeserializeOwned, Serialize};
 use ssz::Encode;
-use std::convert::TryFrom;
 use std::fmt;
 use std::future::Future;
-use std::iter::Iterator;
 use std::path::PathBuf;
 use std::time::Duration;
 use store::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedResponse;

common/eth2/src/types.rs

@@ -12,7 +12,6 @@ use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
 use ssz::{Decode, DecodeError};
 use ssz_derive::{Decode, Encode};
-use std::convert::TryFrom;
 use std::fmt::{self, Display};
 use std::str::{from_utf8, FromStr};
 use std::sync::Arc;

common/eth2_interop_keypairs/src/lib.rs

@@ -23,7 +23,6 @@ use bls::{Keypair, PublicKey, SecretKey};
 use ethereum_hashing::hash;
 use num_bigint::BigUint;
 use serde::{Deserialize, Serialize};
-use std::convert::TryInto;
 use std::fs::File;
 use std::path::PathBuf;
 

common/eth2_network_config/src/lib.rs

@@ -462,7 +462,7 @@ mod tests {
     use super::*;
     use ssz::Encode;
     use tempfile::Builder as TempBuilder;
-    use types::{Config, Eth1Data, GnosisEthSpec, Hash256, MainnetEthSpec};
+    use types::{Eth1Data, GnosisEthSpec, MainnetEthSpec};
 
     type E = MainnetEthSpec;
 

common/slot_clock/src/manual_slot_clock.rs

@@ -1,6 +1,5 @@
 use super::SlotClock;
 use parking_lot::RwLock;
-use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 use types::Slot;

consensus/cached_tree_hash/src/cache.rs

@@ -50,7 +50,7 @@ impl TreeHashCache {
     pub fn recalculate_merkle_root(
         &mut self,
         arena: &mut CacheArena,
-        leaves: impl Iterator<Item = [u8; BYTES_PER_CHUNK]> + ExactSizeIterator,
+        leaves: impl ExactSizeIterator<Item = [u8; BYTES_PER_CHUNK]>,
     ) -> Result<Hash256, Error> {
         let dirty_indices = self.update_leaves(arena, leaves)?;
         self.update_merkle_root(arena, dirty_indices)
@@ -60,7 +60,7 @@ impl TreeHashCache {
     pub fn update_leaves(
         &mut self,
         arena: &mut CacheArena,
-        mut leaves: impl Iterator<Item = [u8; BYTES_PER_CHUNK]> + ExactSizeIterator,
+        mut leaves: impl ExactSizeIterator<Item = [u8; BYTES_PER_CHUNK]>,
     ) -> Result<SmallVec8<usize>, Error> {
         let new_leaf_count = leaves.len();
 

consensus/fork_choice/src/fork_choice.rs

@@ -1655,7 +1655,7 @@ pub struct PersistedForkChoice {
 
 #[cfg(test)]
 mod tests {
-    use types::{EthSpec, MainnetEthSpec};
+    use types::MainnetEthSpec;
 
     use super::*;
 

consensus/proto_array/src/ssz_container.rs

@@ -7,7 +7,6 @@ use crate::{
 use ssz::{four_byte_option_impl, Encode};
 use ssz_derive::{Decode, Encode};
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use superstruct::superstruct;
 use types::{Checkpoint, Hash256};
 

consensus/state_processing/src/genesis.rs

@@ -7,7 +7,6 @@ use crate::upgrade::{
 };
 use safe_arith::{ArithError, SafeArith};
 use tree_hash::TreeHash;
-use types::DEPOSIT_TREE_DEPTH;
 use types::*;
 
 /// Initialize a `BeaconState` from genesis data.

consensus/state_processing/src/per_block_processing/process_operations.rs

@@ -6,7 +6,6 @@ use crate::common::{
 };
 use crate::per_block_processing::errors::{BlockProcessingError, IntoWithIndex};
 use crate::VerifySignatures;
-use safe_arith::SafeArith;
 use types::consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR};
 
 pub fn process_operations<T: EthSpec, Payload: AbstractExecPayload<T>>(

consensus/state_processing/src/per_epoch_processing/altair/inactivity_updates.rs

@@ -1,7 +1,5 @@
 use super::ParticipationCache;
 use crate::EpochProcessingError;
-use core::result::Result;
-use core::result::Result::Ok;
 use safe_arith::SafeArith;
 use std::cmp::min;
 use types::beacon_state::BeaconState;

consensus/state_processing/src/per_epoch_processing/altair/participation_flag_updates.rs

@@ -1,6 +1,4 @@
 use crate::EpochProcessingError;
-use core::result::Result;
-use core::result::Result::Ok;
 use types::beacon_state::BeaconState;
 use types::eth_spec::EthSpec;
 use types::participation_flags::ParticipationFlags;

consensus/state_processing/src/per_epoch_processing/historical_roots_update.rs

@@ -1,6 +1,4 @@
 use super::errors::EpochProcessingError;
-use core::result::Result;
-use core::result::Result::Ok;
 use safe_arith::SafeArith;
 use tree_hash::TreeHash;
 use types::beacon_state::BeaconState;

consensus/state_processing/src/per_epoch_processing/resets.rs

@@ -1,6 +1,4 @@
 use super::errors::EpochProcessingError;
-use core::result::Result;
-use core::result::Result::Ok;
 use safe_arith::SafeArith;
 use types::beacon_state::BeaconState;
 use types::eth_spec::EthSpec;

consensus/types/src/beacon_block.rs

@@ -1,10 +1,5 @@
-use crate::beacon_block_body::{
-    BeaconBlockBodyAltair, BeaconBlockBodyBase, BeaconBlockBodyDeneb, BeaconBlockBodyMerge,
-    BeaconBlockBodyRef, BeaconBlockBodyRefMut,
-};
 use crate::test_utils::TestRandom;
 use crate::*;
-use bls::Signature;
 use derivative::Derivative;
 use serde::{Deserialize, Serialize};
 use ssz::{Decode, DecodeError};
@@ -762,8 +757,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> ForkVersionDeserialize
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{test_ssz_tree_hash_pair_with, SeedableRng, TestRandom, XorShiftRng};
+    use crate::test_utils::{test_ssz_tree_hash_pair_with, SeedableRng, XorShiftRng};
-    use crate::{ForkName, MainnetEthSpec};
     use ssz::Encode;
 
     type BeaconBlock = super::BeaconBlock<MainnetEthSpec>;

consensus/types/src/beacon_block_body.rs

@@ -4,7 +4,6 @@ use derivative::Derivative;
 use merkle_proof::{MerkleTree, MerkleTreeError};
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
-use ssz_types::VariableList;
 use std::marker::PhantomData;
 use superstruct::superstruct;
 use test_random_derive::TestRandom;

consensus/types/src/beacon_state.rs

@@ -12,8 +12,6 @@ use safe_arith::{ArithError, SafeArith};
 use serde::{Deserialize, Serialize};
 use ssz::{ssz_encode, Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
-use ssz_types::{typenum::Unsigned, BitVector, FixedVector};
-use std::convert::TryInto;
 use std::hash::Hash;
 use std::{fmt, mem, sync::Arc};
 use superstruct::superstruct;
@@ -1767,7 +1765,8 @@ impl<T: EthSpec> BeaconState<T> {
             BeaconState::Deneb(inner) => BeaconState::Deneb(inner.clone()),
         };
         if config.committee_caches {
-            *res.committee_caches_mut() = self.committee_caches().clone();
+            res.committee_caches_mut()
+                .clone_from(self.committee_caches());
             *res.total_active_balance_mut() = *self.total_active_balance();
         }
         if config.pubkey_cache {

consensus/types/src/beacon_state/committee_cache.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::arithmetic_side_effects)]
 
-use super::BeaconState;
 use crate::*;
 use core::num::NonZeroUsize;
 use safe_arith::SafeArith;

consensus/types/src/beacon_state/tests.rs

@@ -1,6 +1,5 @@
 #![cfg(test)]
 use crate::test_utils::*;
-use crate::test_utils::{SeedableRng, XorShiftRng};
 use beacon_chain::test_utils::{
     interop_genesis_state_with_eth1, test_spec, BeaconChainHarness, EphemeralHarnessType,
     DEFAULT_ETH1_BLOCK_HASH,

consensus/types/src/beacon_state/tree_hash_cache.rs

@@ -10,7 +10,6 @@ use rayon::prelude::*;
 use ssz_derive::{Decode, Encode};
 use ssz_types::VariableList;
 use std::cmp::Ordering;
-use std::iter::ExactSizeIterator;
 use tree_hash::{mix_in_length, MerkleHasher, TreeHash};
 
 /// The number of leaves (including padding) on the `BeaconState` Merkle tree.

consensus/types/src/bls_to_execution_change.rs

@@ -1,6 +1,5 @@
 use crate::test_utils::TestRandom;
 use crate::*;
-use bls::PublicKeyBytes;
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;

consensus/types/src/deposit_data.rs

@@ -1,7 +1,6 @@
 use crate::test_utils::TestRandom;
 use crate::*;
 
-use bls::{PublicKeyBytes, SignatureBytes};
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;

consensus/types/src/deposit_message.rs

@@ -1,7 +1,6 @@
 use crate::test_utils::TestRandom;
 use crate::*;
 
-use bls::PublicKeyBytes;
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;

consensus/types/src/deposit_tree_snapshot.rs

@@ -5,7 +5,6 @@ use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use test_utils::TestRandom;
-use DEPOSIT_TREE_DEPTH;
 
 #[derive(Encode, Decode, Deserialize, Serialize, Clone, Debug, PartialEq, TestRandom)]
 pub struct FinalizedExecutionBlock {

consensus/types/src/eth_spec.rs

@@ -3,8 +3,8 @@ use crate::*;
 use safe_arith::SafeArith;
 use serde::{Deserialize, Serialize};
 use ssz_types::typenum::{
-    bit::B0, UInt, Unsigned, U0, U1024, U1048576, U1073741824, U1099511627776, U128, U131072, U16,
+    bit::B0, UInt, U0, U1024, U1048576, U1073741824, U1099511627776, U128, U131072, U16, U16777216,
-    U16777216, U2, U2048, U256, U32, U4, U4096, U512, U6, U625, U64, U65536, U8, U8192,
+    U2, U2048, U256, U32, U4, U4096, U512, U6, U625, U64, U65536, U8, U8192,
 };
 use ssz_types::typenum::{U17, U9};
 use std::fmt::{self, Debug};

consensus/types/src/execution_payload_header.rs

@@ -6,7 +6,6 @@ use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
-use BeaconStateError;
 
 #[superstruct(
     variants(Merge, Capella, Deneb),

consensus/types/src/fork_name.rs

@@ -1,7 +1,6 @@
 use crate::{ChainSpec, Epoch};
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
-use std::convert::TryFrom;
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 

consensus/types/src/historical_batch.rs

@@ -3,7 +3,6 @@ use crate::*;
 
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
-use ssz_types::FixedVector;
 use test_random_derive::TestRandom;
 use tree_hash_derive::TreeHash;
 

consensus/types/src/indexed_attestation.rs

@@ -106,7 +106,7 @@ mod quoted_variable_list_u64 {
 mod tests {
     use super::*;
     use crate::slot_epoch::Epoch;
-    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use crate::test_utils::{SeedableRng, XorShiftRng};
     use crate::MainnetEthSpec;
 
     #[test]

consensus/types/src/payload.rs

@@ -5,7 +5,6 @@ use serde::{Deserialize, Serialize};
 use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 use std::borrow::Cow;
-use std::convert::TryFrom;
 use std::fmt::Debug;
 use std::hash::Hash;
 use test_random_derive::TestRandom;

consensus/types/src/selection_proof.rs

@@ -5,7 +5,6 @@ use ethereum_hashing::hash;
 use safe_arith::{ArithError, SafeArith};
 use ssz::Encode;
 use std::cmp;
-use std::convert::TryInto;
 
 #[derive(arbitrary::Arbitrary, PartialEq, Debug, Clone)]
 pub struct SelectionProof(Signature);

consensus/types/src/signed_beacon_block.rs

@@ -1,6 +1,5 @@
 use crate::beacon_block_body::format_kzg_commitments;
 use crate::*;
-use bls::Signature;
 use derivative::Derivative;
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};

consensus/types/src/signed_bls_to_execution_change.rs

@@ -1,6 +1,5 @@
 use crate::test_utils::TestRandom;
 use crate::*;
-use bls::Signature;
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;

consensus/types/src/slot_epoch.rs

@@ -19,7 +19,6 @@ use serde::{Deserialize, Serialize};
 use ssz::{Decode, DecodeError, Encode};
 use std::fmt;
 use std::hash::Hash;
-use std::iter::Iterator;
 
 #[cfg(feature = "legacy-arith")]
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, Sub, SubAssign};

consensus/types/src/sqlite.rs

@@ -4,7 +4,6 @@ use rusqlite::{
     types::{FromSql, FromSqlError, ToSql, ToSqlOutput, ValueRef},
     Error,
 };
-use std::convert::TryFrom;
 
 macro_rules! impl_to_from_sql {
     ($type:ty) => {

consensus/types/src/sync_selection_proof.rs

@@ -10,7 +10,6 @@ use safe_arith::{ArithError, SafeArith};
 use ssz::Encode;
 use ssz_types::typenum::Unsigned;
 use std::cmp;
-use std::convert::TryInto;
 
 #[derive(arbitrary::Arbitrary, PartialEq, Debug, Clone)]
 pub struct SyncSelectionProof(Signature);

consensus/types/src/test_utils/test_random.rs

@@ -2,7 +2,6 @@ use crate::*;
 use rand::RngCore;
 use rand::SeedableRng;
 use rand_xorshift::XorShiftRng;
-use ssz_types::typenum::Unsigned;
 use std::marker::PhantomData;
 use std::sync::Arc;
 

consensus/types/src/test_utils/test_random/address.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::Address;
 
 impl TestRandom for Address {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/aggregate_signature.rs

@@ -1,5 +1,4 @@
 use super::*;
-use bls::{AggregateSignature, Signature};
 
 impl TestRandom for AggregateSignature {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/bitfield.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::{BitList, BitVector, Unsigned};
 use smallvec::smallvec;
 
 impl<N: Unsigned + Clone> TestRandom for BitList<N> {

consensus/types/src/test_utils/test_random/hash256.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::Hash256;
 
 impl TestRandom for Hash256 {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/kzg_proof.rs

@@ -1,5 +1,5 @@
 use super::*;
-use kzg::{KzgProof, BYTES_PER_COMMITMENT};
+use kzg::BYTES_PER_COMMITMENT;
 
 impl TestRandom for KzgProof {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/public_key.rs

@@ -1,5 +1,4 @@
 use super::*;
-use bls::{PublicKey, SecretKey};
 
 impl TestRandom for PublicKey {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/public_key_bytes.rs

@@ -1,6 +1,4 @@
-use std::convert::From;
+use bls::PUBLIC_KEY_BYTES_LEN;
-
-use bls::{PublicKeyBytes, PUBLIC_KEY_BYTES_LEN};
 
 use super::*;
 

consensus/types/src/test_utils/test_random/secret_key.rs

@@ -1,5 +1,4 @@
 use super::*;
-use bls::SecretKey;
 
 impl TestRandom for SecretKey {
     fn random_for_test(_rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/signature.rs

@@ -1,5 +1,4 @@
 use super::*;
-use bls::{SecretKey, Signature};
 
 impl TestRandom for Signature {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/signature_bytes.rs

@@ -1,7 +1,6 @@
-use bls::{SignatureBytes, SIGNATURE_BYTES_LEN};
+use bls::SIGNATURE_BYTES_LEN;
 
 use super::*;
-use std::convert::From;
 
 impl TestRandom for SignatureBytes {
     fn random_for_test(rng: &mut impl RngCore) -> Self {

consensus/types/src/test_utils/test_random/uint256.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::Uint256;
 
 impl TestRandom for Uint256 {
     fn random_for_test(rng: &mut impl RngCore) -> Self {