diff --git a/api/src/context.rs b/api/src/context.rs
index 0293524d48d5f..25d29f614514c 100644
--- a/api/src/context.rs
+++ b/api/src/context.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_api_types::{Error, LedgerInfo, TransactionOnChainData};
-use aptos_config::config::{ApiConfig, RoleType};
+use aptos_config::config::ApiConfig;
 use aptos_crypto::HashValue;
 use aptos_mempool::{MempoolClientRequest, MempoolClientSender, SubmissionStatus};
 use aptos_types::{
@@ -34,7 +34,6 @@ pub struct Context {
     chain_id: ChainId,
     db: Arc<dyn DbReader>,
     mp_sender: MempoolClientSender,
-    role: RoleType,
     api_config: ApiConfig,
 }
 
@@ -43,14 +42,12 @@ impl Context {
         chain_id: ChainId,
         db: Arc<dyn DbReader>,
         mp_sender: MempoolClientSender,
-        role: RoleType,
         api_config: ApiConfig,
     ) -> Self {
         Self {
             chain_id,
             db,
             mp_sender,
-            role,
             api_config,
         }
     }
diff --git a/api/src/runtime.rs b/api/src/runtime.rs
index 95377167c656f..332c899bf57e5 100644
--- a/api/src/runtime.rs
+++ b/api/src/runtime.rs
@@ -29,12 +29,11 @@ pub fn bootstrap(
         .build()
         .expect("[api] failed to create runtime");
 
-    let role = config.base.role;
     let api_config = config.api.clone();
     let api = WebServer::from(api_config.clone());
 
     runtime.spawn(async move {
-        let context = Context::new(chain_id, db, mp_sender, role, api_config);
+        let context = Context::new(chain_id, db, mp_sender, api_config);
         let routes = index::routes(context);
         api.serve(routes).await;
     });
diff --git a/api/src/tests/events_test.rs b/api/src/tests/events_test.rs
index a7ece471f4796..dc7f188615ca4 100644
--- a/api/src/tests/events_test.rs
+++ b/api/src/tests/events_test.rs
@@ -122,7 +122,7 @@ async fn test_get_events_by_struct_type_has_generic_type_parameter() {
     // Instead of creating the example, we just look up an event handle that does not exist.
     let path = format!(
         "/accounts/0x1/events/{}/coin",
-        utf8_percent_encode("0x1::TestCoin::Balance<0x1::ABC::ABC>", NON_ALPHANUMERIC).to_string()
+        utf8_percent_encode("0x1::TestCoin::Balance<0x1::ABC::ABC>", NON_ALPHANUMERIC)
     );
     let resp = context.expect_status_code(404).get(path.as_str()).await;
     context.check_golden_output(resp);
diff --git a/api/src/tests/golden_output.rs b/api/src/tests/golden_output.rs
index eca3bc635d68d..ada67efca5401 100644
--- a/api/src/tests/golden_output.rs
+++ b/api/src/tests/golden_output.rs
@@ -21,7 +21,7 @@ pub(crate) struct GoldenOutputs {
 
 fn golden_path() -> PathBuf {
     let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    path.push(GOLDEN_DIR_PATH.to_string());
+    path.push(GOLDEN_DIR_PATH);
     path
 }
 
diff --git a/api/src/tests/test_context.rs b/api/src/tests/test_context.rs
index 5ee38c51415fa..7ef4cf577d414 100644
--- a/api/src/tests/test_context.rs
+++ b/api/src/tests/test_context.rs
@@ -6,7 +6,7 @@ use aptos_api_types::{
     mime_types, HexEncodedBytes, TransactionOnChainData, X_APTOS_CHAIN_ID,
     X_APTOS_LEDGER_TIMESTAMP, X_APTOS_LEDGER_VERSION,
 };
-use aptos_config::config::{ApiConfig, RoleType};
+use aptos_config::config::ApiConfig;
 use aptos_crypto::{hash::HashValue, SigningKey};
 use aptos_genesis_tool::validator_builder::{RootKeys, ValidatorBuilder};
 use aptos_global_constants::OWNER_ACCOUNT;
@@ -72,7 +72,6 @@ pub fn new_test_context(test_name: &'static str) -> TestContext {
             ChainId::test(),
             db.clone(),
             mempool.ac_client.clone(),
-            RoleType::Validator,
             ApiConfig::default(),
         ),
         rng,
@@ -128,7 +127,7 @@ impl TestContext {
 
     pub fn check_golden_output(&mut self, msg: Value) {
         if self.golden_output.is_none() {
-            self.golden_output = Some(GoldenOutputs::new(self.test_name.replace(":", "_")));
+            self.golden_output = Some(GoldenOutputs::new(self.test_name.replace(':', "_")));
         }
         self.golden_output.as_ref().unwrap().log(&pretty(&msg));
     }
diff --git a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
index 8df3f0b765f49..7d89d5fbd552d 100644
--- a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
+++ b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
@@ -1,6 +1,9 @@
 // Copyright (c) Aptos
 // SPDX-License-Identifier: Apache-2.0
 
+// We're currently evaluating the future of this crate
+#![allow(dead_code)]
+
 use anyhow::{bail, format_err, Result};
 use aptos_crypto::{
     ed25519::{Ed25519PrivateKey, Ed25519PublicKey},
diff --git a/aptos-move/aptos-vm/src/adapter_common.rs b/aptos-move/aptos-vm/src/adapter_common.rs
index 3f303f28b29ce..72b9bcc73e1bf 100644
--- a/aptos-move/aptos-vm/src/adapter_common.rs
+++ b/aptos-move/aptos-vm/src/adapter_common.rs
@@ -131,14 +131,14 @@ pub fn validate_signed_transaction<A: VMAdapter>(
 
 pub(crate) fn validate_signature_checked_transaction<S: MoveResolver, A: VMAdapter>(
     adapter: &A,
-    mut session: &mut SessionExt<S>,
+    session: &mut SessionExt<S>,
     transaction: &SignatureCheckedTransaction,
     allow_too_new: bool,
     log_context: &AdapterLogSchema,
 ) -> Result<(), VMStatus> {
     adapter.check_transaction_format(transaction)?;
 
-    let prologue_status = adapter.run_prologue(&mut session, transaction, log_context);
+    let prologue_status = adapter.run_prologue(session, transaction, log_context);
     match prologue_status {
         Err(err) if !allow_too_new || err.status_code() != StatusCode::SEQUENCE_NUMBER_TOO_NEW => {
             Err(err)
diff --git a/aptos-move/aptos-vm/src/aptos_vm_impl.rs b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
index 7db6b634121c5..2cc770b91c24c 100644
--- a/aptos-move/aptos-vm/src/aptos_vm_impl.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
@@ -265,9 +265,7 @@ impl AptosVMImpl {
         let secondary_public_key_hashes: Vec<MoveValue> = txn_data
             .secondary_authentication_key_preimages
             .iter()
-            .map(|preimage| {
-                MoveValue::vector_u8(HashValue::sha3_256_of(&preimage.to_vec()).to_vec())
-            })
+            .map(|preimage| MoveValue::vector_u8(HashValue::sha3_256_of(preimage).to_vec()))
             .collect();
         let args = if self.get_version()? >= APTOS_VERSION_3 && txn_data.is_multi_agent() {
             vec![
diff --git a/aptos-move/e2e-tests/src/executor.rs b/aptos-move/e2e-tests/src/executor.rs
index 0474d87858952..c46254bef6e5e 100644
--- a/aptos-move/e2e-tests/src/executor.rs
+++ b/aptos-move/e2e-tests/src/executor.rs
@@ -273,13 +273,7 @@ impl FakeExecutor {
         let ap = AccessPath::resource_access_path(ResourceKey::new(*addr, T::struct_tag()));
         let data_blob = StateView::get_state_value(&self.data_store, &StateKey::AccessPath(ap))
             .expect("account must exist in data store")
-            .unwrap_or_else(|| {
-                panic!(
-                    "Can't fetch {} resource for {}",
-                    T::STRUCT_NAME.to_string(),
-                    addr
-                )
-            });
+            .unwrap_or_else(|| panic!("Can't fetch {} resource for {}", T::STRUCT_NAME, addr));
         bcs::from_bytes(data_blob.as_slice()).ok()
     }
 
diff --git a/aptos-move/e2e-tests/src/golden_outputs.rs b/aptos-move/e2e-tests/src/golden_outputs.rs
index f14e32a4fd6e9..396985fa1d639 100644
--- a/aptos-move/e2e-tests/src/golden_outputs.rs
+++ b/aptos-move/e2e-tests/src/golden_outputs.rs
@@ -15,7 +15,7 @@ pub(crate) struct GoldenOutputs {
 
 fn golden_path() -> PathBuf {
     let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    path.push(GOLDEN_DIR_PATH.to_string());
+    path.push(GOLDEN_DIR_PATH);
     path
 }
 
diff --git a/aptos-move/transaction-builder-generator/src/typescript.rs b/aptos-move/transaction-builder-generator/src/typescript.rs
index 55818559c6a6b..6a87a01a59991 100644
--- a/aptos-move/transaction-builder-generator/src/typescript.rs
+++ b/aptos-move/transaction-builder-generator/src/typescript.rs
@@ -465,7 +465,7 @@ return new AptosTypes.Script(code, tyArgs, args);"#,
 }},
             "#,
             abi.name().to_camel_case(),
-            abi.doc().replace("\"", "\\\"").replace("\n", "\" + \n \""),
+            abi.doc().replace('\"', "\\\"").replace('\n', "\" + \n \""),
             abi.ty_args()
                 .iter()
                 .map(|ty_arg| format!("\"{}\"", ty_arg.name()))
@@ -504,7 +504,7 @@ return new AptosTypes.Script(code, tyArgs, args);"#,
         writeln!(
             self.out,
             "  description: \"{}\",",
-            abi.doc().replace("\"", "\\\"").replace("\n", "\" + \n \"")
+            abi.doc().replace('\"', "\\\"").replace('\n', "\" + \n \"")
         )?;
         writeln!(
             self.out,
diff --git a/aptos-move/transaction-replay/src/main.rs b/aptos-move/transaction-replay/src/main.rs
index 3aff81e21eb79..4b7b0e841470b 100644
--- a/aptos-move/transaction-replay/src/main.rs
+++ b/aptos-move/transaction-replay/src/main.rs
@@ -18,9 +18,6 @@ struct Opt {
     /// Path to the local AptosDB file
     #[structopt(long, parse(from_os_str))]
     db: Option<PathBuf>,
-    /// Full URL address to connect to - should include port number, if applicable
-    #[structopt(short = "u", long)]
-    url: Option<String>,
     /// If true, persist the effects of replaying transactions via `cmd` to disk in a format understood by the Move CLI
     #[structopt(short = "s", global = true)]
     save_write_sets: bool,
diff --git a/aptos-move/writeset-transaction-generator/src/admin_script_builder.rs b/aptos-move/writeset-transaction-generator/src/admin_script_builder.rs
index e29378fd1c876..e6de68faea056 100644
--- a/aptos-move/writeset-transaction-generator/src/admin_script_builder.rs
+++ b/aptos-move/writeset-transaction-generator/src/admin_script_builder.rs
@@ -45,7 +45,7 @@ fn compile_admin_script(input: &str) -> Result<Script> {
 
 pub fn template_path() -> PathBuf {
     let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    path.push(SCRIPTS_DIR_PATH.to_string());
+    path.push(SCRIPTS_DIR_PATH);
     path
 }
 
diff --git a/clippy.toml b/clippy.toml
index 68a8a8a66988a..e49be41857f09 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -4,3 +4,5 @@ cognitive-complexity-threshold = 100
 type-complexity-threshold = 10000
 # manipulating complex states machines in consensus
 too-many-arguments-threshold = 13
+# Reasonably large enum variants are okay
+enum-variant-size-threshold = 1000
diff --git a/config/management/genesis/src/genesis.rs b/config/management/genesis/src/genesis.rs
index a6e1af1f04945..72b0e6c9d44a2 100644
--- a/config/management/genesis/src/genesis.rs
+++ b/config/management/genesis/src/genesis.rs
@@ -53,13 +53,13 @@ impl Genesis {
 
         if let Some(path) = self.path {
             let mut file = File::create(path).map_err(|e| {
-                Error::UnexpectedError(format!("Unable to create genesis file: {}", e.to_string()))
+                Error::UnexpectedError(format!("Unable to create genesis file: {}", e))
             })?;
             let bytes = bcs::to_bytes(&genesis).map_err(|e| {
-                Error::UnexpectedError(format!("Unable to serialize genesis: {}", e.to_string()))
+                Error::UnexpectedError(format!("Unable to serialize genesis: {}", e))
             })?;
             file.write_all(&bytes).map_err(|e| {
-                Error::UnexpectedError(format!("Unable to write genesis file: {}", e.to_string()))
+                Error::UnexpectedError(format!("Unable to write genesis file: {}", e))
             })?;
         }
 
diff --git a/config/management/genesis/src/verify.rs b/config/management/genesis/src/verify.rs
index 10c9d1f720d13..ec053b95a2013 100644
--- a/config/management/genesis/src/verify.rs
+++ b/config/management/genesis/src/verify.rs
@@ -243,15 +243,13 @@ fn validator_config(
         .get_latest_state_value(StateKey::AccountAddressKey(
             account_config::validator_set_address(),
         ))
-        .map_err(|e| {
-            Error::UnexpectedError(format!("ValidatorSet Account issue {}", e.to_string()))
-        })?
+        .map_err(|e| Error::UnexpectedError(format!("ValidatorSet Account issue {}", e)))?
         .ok_or_else(|| Error::UnexpectedError("ValidatorSet Account not found".into()))?;
     let account_state = AccountState::try_from(&blob)
         .map_err(|e| Error::UnexpectedError(format!("Failed to parse blob: {}", e)))?;
     let validator_set: ValidatorSet = account_state
         .get_validator_set()
-        .map_err(|e| Error::UnexpectedError(format!("ValidatorSet issue {}", e.to_string())))?
+        .map_err(|e| Error::UnexpectedError(format!("ValidatorSet issue {}", e)))?
         .ok_or_else(|| Error::UnexpectedError("ValidatorSet does not exist".into()))?;
     let info = validator_set
         .payload()
diff --git a/config/management/operational/src/account_resource.rs b/config/management/operational/src/account_resource.rs
index b9b527320ed6c..27b2364653764 100644
--- a/config/management/operational/src/account_resource.rs
+++ b/config/management/operational/src/account_resource.rs
@@ -81,7 +81,7 @@ impl RotateOperatorKey {
             Err(e) => {
                 return Err(Error::UnexpectedError(format!(
                     "Invalid authentication key found in account resource. Error: {}",
-                    e.to_string()
+                    e,
                 )));
             }
         };
diff --git a/config/management/operational/src/validator_config.rs b/config/management/operational/src/validator_config.rs
index fd19a6dee9149..4a6e2395758f6 100644
--- a/config/management/operational/src/validator_config.rs
+++ b/config/management/operational/src/validator_config.rs
@@ -6,7 +6,7 @@ use aptos_crypto::{ed25519::Ed25519PublicKey, x25519};
 use aptos_global_constants::{
     CONSENSUS_KEY, FULLNODE_NETWORK_KEY, OPERATOR_ACCOUNT, OWNER_ACCOUNT, VALIDATOR_NETWORK_KEY,
 };
-use aptos_management::{error::Error, secure_backend::ValidatorBackend, storage::to_x25519};
+use aptos_management::{error::Error, storage::to_x25519};
 use aptos_types::{
     account_address::AccountAddress,
     network_address::{NetworkAddress, Protocol},
@@ -267,11 +267,6 @@ pub struct ValidatorConfig {
     /// JSON-RPC Endpoint (e.g. http://localhost:8080)
     #[structopt(long, required_unless = "config")]
     json_server: Option<String>,
-    #[structopt(
-        long,
-        help = "The secure backend that contains the network address encryption keys"
-    )]
-    validator_backend: Option<ValidatorBackend>,
 }
 
 impl ValidatorConfig {
diff --git a/config/management/operational/src/validator_set.rs b/config/management/operational/src/validator_set.rs
index 69da1c28b69b9..6f8d192cefe3d 100644
--- a/config/management/operational/src/validator_set.rs
+++ b/config/management/operational/src/validator_set.rs
@@ -6,7 +6,7 @@ use crate::{
     validator_config::{fullnode_addresses, validator_addresses, DecodedValidatorConfig},
 };
 use aptos_crypto::ed25519::Ed25519PublicKey;
-use aptos_management::{config::ConfigPath, error::Error, secure_backend::ValidatorBackend};
+use aptos_management::{config::ConfigPath, error::Error};
 use aptos_types::{
     account_address::AccountAddress, network_address::NetworkAddress, validator_info::ValidatorInfo,
 };
@@ -22,11 +22,6 @@ pub struct ValidatorSet {
     json_server: Option<String>,
     #[structopt(long, help = "AccountAddress to retrieve the validator set info")]
     account_address: Option<AccountAddress>,
-    #[structopt(
-        long,
-        help = "The secure backend that contains the network address encryption keys"
-    )]
-    validator_backend: Option<ValidatorBackend>,
 }
 
 impl ValidatorSet {
diff --git a/consensus/src/block_storage/block_store.rs b/consensus/src/block_storage/block_store.rs
index fdb9018859285..de96c21568628 100644
--- a/consensus/src/block_storage/block_store.rs
+++ b/consensus/src/block_storage/block_store.rs
@@ -260,7 +260,7 @@ impl BlockStore {
 
         let blocks_to_commit = self
             .path_from_ordered_root(block_id_to_commit)
-            .unwrap_or_else(Vec::new);
+            .unwrap_or_default();
 
         assert!(!blocks_to_commit.is_empty());
 
@@ -359,7 +359,7 @@ impl BlockStore {
                 // recover the block tree in executor
                 let blocks_to_reexecute = self
                     .path_from_ordered_root(parent_block_id)
-                    .unwrap_or_else(Vec::new);
+                    .unwrap_or_default();
 
                 for block in blocks_to_reexecute {
                     self.execute_block(block.block().clone()).await?;
diff --git a/consensus/src/epoch_manager.rs b/consensus/src/epoch_manager.rs
index cbdc97956df39..471e80d7c2188 100644
--- a/consensus/src/epoch_manager.rs
+++ b/consensus/src/epoch_manager.rs
@@ -586,8 +586,7 @@ impl EpochManager {
         event: VerifiedEvent,
     ) -> anyhow::Result<()> {
         match event {
-            buffer_manager_event
-            @ (VerifiedEvent::CommitVote(_)
+            buffer_manager_event @ (VerifiedEvent::CommitVote(_)
             | VerifiedEvent::CommitDecision(_)) => {
                 if let Some(sender) = &mut self.buffer_manager_msg_tx {
                     sender.push(peer_id, buffer_manager_event)?;
diff --git a/consensus/src/twins/twins_node.rs b/consensus/src/twins/twins_node.rs
index 2c04c5d9bfc17..cbab94c42b41e 100644
--- a/consensus/src/twins/twins_node.rs
+++ b/consensus/src/twins/twins_node.rs
@@ -186,7 +186,7 @@ impl SMRNode {
                 .collect(),
         );
         // sort by the peer id
-        node_configs.sort_by_key(|n1| author_from_config(n1));
+        node_configs.sort_by_key(author_from_config);
 
         let proposer_type = match proposer_type {
             RoundProposer(_) => {
diff --git a/crates/aptos-crypto-derive/src/lib.rs b/crates/aptos-crypto-derive/src/lib.rs
index 96e57681045fe..196e82e620e17 100644
--- a/crates/aptos-crypto-derive/src/lib.rs
+++ b/crates/aptos-crypto-derive/src/lib.rs
@@ -415,7 +415,7 @@ pub fn bcs_crypto_hash_dispatch(input: TokenStream) -> TokenStream {
     let name = &ast.ident;
     let hasher_name = Ident::new(&format!("{}Hasher", &name.to_string()), Span::call_site());
     let error_msg = syn::LitStr::new(
-        &format!("BCS serialization of {} should not fail", name.to_string()),
+        &format!("BCS serialization of {} should not fail", name),
         Span::call_site(),
     );
     let generics = add_trait_bounds(ast.generics);
diff --git a/crates/aptos-crypto/src/hkdf.rs b/crates/aptos-crypto/src/hkdf.rs
index 509c8020485e7..661cc58fbe311 100644
--- a/crates/aptos-crypto/src/hkdf.rs
+++ b/crates/aptos-crypto/src/hkdf.rs
@@ -139,7 +139,7 @@ where
         let hkdf =
             hkdf::Hkdf::<D>::from_prk(prk).map_err(|_| HkdfError::WrongPseudorandomKeyError)?;
         let mut okm = vec![0u8; length];
-        hkdf.expand(info.unwrap_or_else(|| &[]), &mut okm)
+        hkdf.expand(info.unwrap_or(&[]), &mut okm)
             // length > D::OutputSize::to_usize() * 255
             .map_err(|_| HkdfError::InvalidOutputLengthError)?;
         Ok(okm)
diff --git a/crates/aptos-crypto/src/noise.rs b/crates/aptos-crypto/src/noise.rs
index 4300ac041ab55..7a0980317dfc4 100644
--- a/crates/aptos-crypto/src/noise.rs
+++ b/crates/aptos-crypto/src/noise.rs
@@ -181,7 +181,7 @@ fn hash(data: &[u8]) -> Vec<u8> {
 }
 
 fn hkdf(ck: &[u8], dh_output: Option<&[u8]>) -> Result<(Vec<u8>, Vec<u8>), NoiseError> {
-    let dh_output = dh_output.unwrap_or_else(|| &[]);
+    let dh_output = dh_output.unwrap_or(&[]);
     let hkdf_output = if dh_output.is_empty() {
         Hkdf::<sha2::Sha256>::extract_then_expand_no_ikm(Some(ck), None, 64)
     } else {
@@ -326,7 +326,7 @@ impl NoiseConfig {
         let aead = Aes256Gcm::new(GenericArray::from_slice(&k));
 
         let msg_and_ad = Payload {
-            msg: payload.unwrap_or_else(|| &[]),
+            msg: payload.unwrap_or(&[]),
             aad: &h,
         };
         let nonce = GenericArray::from_slice(&[0u8; AES_NONCE_SIZE]);
@@ -547,7 +547,7 @@ impl NoiseConfig {
         let aead = Aes256Gcm::new(GenericArray::from_slice(&k));
 
         let msg_and_ad = Payload {
-            msg: payload.unwrap_or_else(|| &[]),
+            msg: payload.unwrap_or(&[]),
             aad: &h,
         };
         let nonce = GenericArray::from_slice(&[0u8; AES_NONCE_SIZE]);
diff --git a/crates/aptos-faucet/src/main.rs b/crates/aptos-faucet/src/main.rs
index 3f3944388f261..961e5f338f74b 100644
--- a/crates/aptos-faucet/src/main.rs
+++ b/crates/aptos-faucet/src/main.rs
@@ -454,12 +454,12 @@ mod tests {
 
         let resp = warp::test::request()
             .method("GET")
-            .path(&"/health".to_string())
+            .path("/health")
             .reply(&routes(service))
             .await;
 
         assert_eq!(resp.status(), 200);
-        assert_eq!(resp.body(), 0.to_string().as_str());
+        assert_eq!(resp.body(), std::string::ToString::to_string(&0).as_str());
     }
 
     #[tokio::test]
diff --git a/crates/aptos-logger/src/aptos_logger.rs b/crates/aptos-logger/src/aptos_logger.rs
index 1ebf091c28ea6..e6c442be4c619 100644
--- a/crates/aptos-logger/src/aptos_logger.rs
+++ b/crates/aptos-logger/src/aptos_logger.rs
@@ -133,7 +133,7 @@ impl LogEntry {
     }
 
     pub fn hostname(&self) -> Option<&str> {
-        self.hostname.as_deref()
+        self.hostname
     }
 
     pub fn timestamp(&self) -> &str {
@@ -517,7 +517,7 @@ impl Writer for FileWriter {
     /// Write to file
     fn write(&self, log: String) {
         if let Err(err) = writeln!(self.log_file.write(), "{}", log) {
-            eprintln!("Unable to write to log file: {}", err.to_string());
+            eprintln!("Unable to write to log file: {}", err);
         }
     }
 }
diff --git a/crates/aptos-logger/src/lib.rs b/crates/aptos-logger/src/lib.rs
index fef07c9cf1ab7..5fd51bbbf5b8c 100644
--- a/crates/aptos-logger/src/lib.rs
+++ b/crates/aptos-logger/src/lib.rs
@@ -143,7 +143,7 @@ pub mod prelude {
     };
 }
 
-mod aptos_logger;
+pub mod aptos_logger;
 mod event;
 mod filter;
 mod kv;
@@ -156,9 +156,7 @@ pub mod tracing_adapter;
 mod security;
 mod struct_log;
 
-pub use crate::aptos_logger::{
-    AptosData, AptosData as Logger, AptosDataBuilder, Writer, CHANNEL_SIZE,
-};
+pub use crate::aptos_logger::{AptosData as Logger, AptosDataBuilder, Writer, CHANNEL_SIZE};
 pub use event::Event;
 pub use filter::{Filter, LevelFilter};
 pub use logger::flush;
diff --git a/crates/aptos-logger/tests/logger.rs b/crates/aptos-logger/tests/logger.rs
index e575ce1dcabca..59cd56a9eb72a 100644
--- a/crates/aptos-logger/tests/logger.rs
+++ b/crates/aptos-logger/tests/logger.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_infallible::RwLock;
-use aptos_logger::{info, AptosData, Writer};
+use aptos_logger::{aptos_logger::AptosData, info, Writer};
 use std::sync::Arc;
 
 #[derive(Default)]
diff --git a/crates/aptos-logger/tests/logger_custom_format.rs b/crates/aptos-logger/tests/logger_custom_format.rs
index 84859c7550942..8a03c34a06a45 100644
--- a/crates/aptos-logger/tests/logger_custom_format.rs
+++ b/crates/aptos-logger/tests/logger_custom_format.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_infallible::RwLock;
-use aptos_logger::{info, AptosData, Writer};
+use aptos_logger::{aptos_logger::AptosData, info, Writer};
 use std::sync::Arc;
 
 #[derive(Default)]
diff --git a/crates/aptos-logger/tests/remote.rs b/crates/aptos-logger/tests/remote.rs
index 48362ca7baa89..67a35bc84b868 100644
--- a/crates/aptos-logger/tests/remote.rs
+++ b/crates/aptos-logger/tests/remote.rs
@@ -1,7 +1,7 @@
 // Copyright (c) Aptos
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_logger::{debug, error, trace, AptosData, Level};
+use aptos_logger::{aptos_logger::AptosData, debug, error, trace, Level};
 use serde::Deserialize;
 use std::{
     io::{BufRead, BufReader},
diff --git a/crates/aptos-logger/tests/tracing_translation_tests.rs b/crates/aptos-logger/tests/tracing_translation_tests.rs
index dc1b5ade2f02f..71078e9f5b6cb 100644
--- a/crates/aptos-logger/tests/tracing_translation_tests.rs
+++ b/crates/aptos-logger/tests/tracing_translation_tests.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_infallible::RwLock;
-use aptos_logger::{AptosData, Writer};
+use aptos_logger::{aptos_logger::AptosData, Writer};
 use std::sync::Arc;
 use tracing::Level;
 
diff --git a/crates/aptos-metrics/src/op_counters.rs b/crates/aptos-metrics/src/op_counters.rs
index 1c7eeed5ef38c..a4bbc4fea305c 100644
--- a/crates/aptos-metrics/src/op_counters.rs
+++ b/crates/aptos-metrics/src/op_counters.rs
@@ -39,7 +39,6 @@ impl DurationHistogram {
 
 #[derive(Clone)]
 pub struct OpMetrics {
-    module: String,
     counters: IntCounterVec,
     gauges: IntGaugeVec,
     peer_gauges: IntGaugeVec,
@@ -50,7 +49,6 @@ impl OpMetrics {
     pub fn new<S: Into<String>>(name: S) -> OpMetrics {
         let name_str = name.into();
         OpMetrics {
-            module: name_str.clone(),
             counters: IntCounterVec::new(
                 Opts::new(name_str.clone(), format!("Counters for {}", name_str)),
                 &["op"],
diff --git a/crates/aptos-rate-limiter/src/main.rs b/crates/aptos-rate-limiter/src/main.rs
index e7da0b5fa041b..afec09658dfa8 100644
--- a/crates/aptos-rate-limiter/src/main.rs
+++ b/crates/aptos-rate-limiter/src/main.rs
@@ -49,7 +49,7 @@ struct RunStats {
 
 /// A main function for testing rate limiting throughput and backpressure
 fn main() {
-    aptos_logger::AptosData::init_for_testing();
+    aptos_logger::Logger::init_for_testing();
     println!("Starting experiments");
     println!(
         "Bytes to test: {}, Expected Throughput(actions/s): {}, Expected Throughput(bytes/s): {}",
diff --git a/crates/aptos-telemetry/src/lib.rs b/crates/aptos-telemetry/src/lib.rs
index 67d42f2df00d4..bee4d9367e605 100644
--- a/crates/aptos-telemetry/src/lib.rs
+++ b/crates/aptos-telemetry/src/lib.rs
@@ -61,9 +61,10 @@ pub async fn send_data(event_name: String, user_id: String, event_params: HashMa
     }
 
     // parse environment variables
-    let api_secret = env::var(GA_API_SECRET).unwrap_or_else(|_| constants::APTOS_GA_API_SECRET.to_string());
-    let measurement_id =
-        env::var(GA_MEASUREMENT_ID).unwrap_or_else(|_| constants::APTOS_GA_MEASUREMENT_ID.to_string());
+    let api_secret =
+        env::var(GA_API_SECRET).unwrap_or_else(|_| constants::APTOS_GA_API_SECRET.to_string());
+    let measurement_id = env::var(GA_MEASUREMENT_ID)
+        .unwrap_or_else(|_| constants::APTOS_GA_MEASUREMENT_ID.to_string());
 
     // dump event params in a new hashmap with some default params to include
     let mut new_event_params: HashMap<String, String> = event_params.clone();
diff --git a/crates/transaction-emitter/src/cluster.rs b/crates/transaction-emitter/src/cluster.rs
index ed598f9165c31..bbdafc6fef0e3 100644
--- a/crates/transaction-emitter/src/cluster.rs
+++ b/crates/transaction-emitter/src/cluster.rs
@@ -24,7 +24,6 @@ use aptos_sdk::{
     },
 };
 use rand::seq::SliceRandom;
-use reqwest::Client;
 use std::{convert::TryFrom, path::Path};
 
 const DD_KEY: &str = "dd.key";
@@ -47,7 +46,6 @@ impl Cluster {
         chain_id: ChainId,
         vasp: bool,
     ) -> Self {
-        let http_client = Client::new();
         let instances: Vec<Instance> = peers
             .into_iter()
             .map(|host_port| {
@@ -56,7 +54,6 @@ impl Cluster {
                     host_port.0,
                     host_port.1,
                     host_port.2,
-                    http_client.clone(),
                 )
             })
             .collect();
diff --git a/crates/transaction-emitter/src/instance.rs b/crates/transaction-emitter/src/instance.rs
index 8096dbb2f9f4e..2eb713023c9a1 100644
--- a/crates/transaction-emitter/src/instance.rs
+++ b/crates/transaction-emitter/src/instance.rs
@@ -3,7 +3,7 @@
 
 use anyhow::{format_err, Result};
 use aptos_rest_client::Client as RestClient;
-use reqwest::{Client, Url};
+use reqwest::Url;
 use std::{
     fmt,
     str::FromStr,
@@ -17,8 +17,6 @@ pub struct Instance {
     ip: String,
     ac_port: u32,
     debug_interface_port: Option<u32>,
-    // todo: remove this, no where is using it
-    http_client: Client,
 }
 
 impl Instance {
@@ -27,14 +25,12 @@ impl Instance {
         ip: String,
         ac_port: u32,
         debug_interface_port: Option<u32>,
-        http_client: Client,
     ) -> Instance {
         Instance {
             peer_name,
             ip,
             ac_port,
             debug_interface_port,
-            http_client,
         }
     }
 
diff --git a/crates/transaction-emitter/src/lib.rs b/crates/transaction-emitter/src/lib.rs
index 5239ba2cb4c6b..b87a246e4963a 100644
--- a/crates/transaction-emitter/src/lib.rs
+++ b/crates/transaction-emitter/src/lib.rs
@@ -1,8 +1,8 @@
 // Copyright (c) Aptos
 // SPDX-License-Identifier: Apache-2.0
 
+use ::aptos_logger::*;
 use anyhow::{format_err, Context, Result};
-use aptos_logger::*;
 use aptos_rest_client::{Client as RestClient, PendingTransaction, Response};
 use aptos_sdk::{
     move_types::account_address::AccountAddress,
diff --git a/crates/transaction-emitter/src/main.rs b/crates/transaction-emitter/src/main.rs
index 37cb647955991..7b29d54ed104e 100644
--- a/crates/transaction-emitter/src/main.rs
+++ b/crates/transaction-emitter/src/main.rs
@@ -28,8 +28,6 @@ struct Args {
     #[structopt(long, help = "If set, tries to use public peers instead of localhost")]
     vasp: bool,
 
-    #[structopt(long)]
-    health_check: bool,
     #[structopt(long)]
     emit_tx: bool,
     #[structopt(long)]
diff --git a/devtools/x/src/playground.rs b/devtools/x/src/playground.rs
index a7a18e48499f4..fbf622b2c97c0 100644
--- a/devtools/x/src/playground.rs
+++ b/devtools/x/src/playground.rs
@@ -104,6 +104,7 @@ impl ContentLinter for PlaygroundContent {
 #[derive(Debug, StructOpt)]
 pub struct Args {
     /// Dummy arg that doesn't do anything
+    #[allow(dead_code)]
     #[structopt(long)]
     dummy: bool,
 }
diff --git a/execution/executor-types/src/executed_chunk.rs b/execution/executor-types/src/executed_chunk.rs
index 276777ff17fbf..e7e351f50002e 100644
--- a/execution/executor-types/src/executed_chunk.rs
+++ b/execution/executor-types/src/executed_chunk.rs
@@ -65,8 +65,7 @@ impl ExecutedChunk {
     pub fn events_to_commit(&self) -> Vec<ContractEvent> {
         self.to_commit
             .iter()
-            .map(|(_, txn_data)| txn_data.events())
-            .flatten()
+            .flat_map(|(_, txn_data)| txn_data.events())
             .cloned()
             .collect()
     }
diff --git a/execution/executor/src/components/chunk_output.rs b/execution/executor/src/components/chunk_output.rs
index d9bd9f1d383b5..0fd935dc2f750 100644
--- a/execution/executor/src/components/chunk_output.rs
+++ b/execution/executor/src/components/chunk_output.rs
@@ -53,8 +53,7 @@ impl ChunkOutput {
         // collect all accounts touched and dedup
         let access_paths = transaction_outputs
             .iter()
-            .map(|o| o.write_set())
-            .flatten()
+            .flat_map(|o| o.write_set())
             .collect::<HashSet<_>>();
 
         // prime the state cache by fetching all touched accounts
diff --git a/network/builder/src/builder.rs b/network/builder/src/builder.rs
index fc1a1c828ed47..377d357cd273c 100644
--- a/network/builder/src/builder.rs
+++ b/network/builder/src/builder.rs
@@ -229,7 +229,7 @@ impl NetworkBuilder {
             let reconfig_listener = if *discovery_method == DiscoveryMethod::Onchain {
                 Some(
                     reconfig_subscription_service
-                        .as_deref_mut()
+                        .as_mut()
                         .expect("An event subscription service is required for on-chain discovery!")
                         .subscribe_to_reconfigurations()
                         .expect("On-chain discovery is unable to subscribe to reconfigurations!"),
diff --git a/network/discovery/src/validator_set.rs b/network/discovery/src/validator_set.rs
index 6eaf44c340c54..816c2908282ab 100644
--- a/network/discovery/src/validator_set.rs
+++ b/network/discovery/src/validator_set.rs
@@ -175,7 +175,7 @@ mod tests {
 
     #[test]
     fn metric_if_key_mismatch() {
-        aptos_logger::AptosData::init_for_testing();
+        aptos_logger::Logger::init_for_testing();
         let runtime = Runtime::new().unwrap();
         let consensus_private_key = Ed25519PrivateKey::generate_for_testing();
         let consensus_pubkey = consensus_private_key.public_key();
diff --git a/network/memsocket/src/lib.rs b/network/memsocket/src/lib.rs
index fdff24ea4f1c0..e4e40d2b42781 100644
--- a/network/memsocket/src/lib.rs
+++ b/network/memsocket/src/lib.rs
@@ -318,7 +318,7 @@ impl AsyncRead for MemorySocket {
     /// Attempt to read from the `AsyncRead` into `buf`.
     fn poll_read(
         mut self: Pin<&mut Self>,
-        mut context: &mut Context,
+        context: &mut Context,
         buf: &mut [u8],
     ) -> Poll<Result<usize>> {
         if self.incoming.is_terminated() {
@@ -354,7 +354,7 @@ impl AsyncRead for MemorySocket {
                 // Either we've exhausted our current buffer or don't have one
                 _ => {
                     self.current_buffer = {
-                        match Pin::new(&mut self.incoming).poll_next(&mut context) {
+                        match Pin::new(&mut self.incoming).poll_next(context) {
                             Poll::Pending => {
                                 // If we've read anything up to this point return the bytes read
                                 if bytes_read > 0 {
diff --git a/network/netcore/src/transport/and_then.rs b/network/netcore/src/transport/and_then.rs
index 920737790a83f..6cf906b3296e1 100644
--- a/network/netcore/src/transport/and_then.rs
+++ b/network/netcore/src/transport/and_then.rs
@@ -154,18 +154,18 @@ where
 {
     type Output = Result<O2, E>;
 
-    fn poll(self: Pin<&mut Self>, mut context: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, context: &mut Context) -> Poll<Self::Output> {
         let mut this = self.project();
         loop {
             let (output, (f, addr, origin)) = match this.chain.as_mut().project() {
                 // Step 1: Drive Fut1 to completion
-                AndThenChainProj::First(fut1, data) => match fut1.poll(&mut context) {
+                AndThenChainProj::First(fut1, data) => match fut1.poll(context) {
                     Poll::Pending => return Poll::Pending,
                     Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),
                     Poll::Ready(Ok(output)) => (output, data.take().expect("must be initialized")),
                 },
                 // Step 4: Drive Fut2 to completion
-                AndThenChainProj::Second(fut2) => return fut2.poll(&mut context),
+                AndThenChainProj::Second(fut2) => return fut2.poll(context),
                 AndThenChainProj::Empty => unreachable!(),
             };
 
diff --git a/network/src/noise/handshake.rs b/network/src/noise/handshake.rs
index 985d606d8a584..447f0140bb95d 100644
--- a/network/src/noise/handshake.rs
+++ b/network/src/noise/handshake.rs
@@ -227,7 +227,7 @@ impl NoiseUpgrader {
         client_message[PeerId::LENGTH..Self::PROLOGUE_SIZE]
             .copy_from_slice(remote_public_key.as_slice());
 
-        let (prologue_msg, mut client_noise_msg) = client_message.split_at_mut(Self::PROLOGUE_SIZE);
+        let (prologue_msg, client_noise_msg) = client_message.split_at_mut(Self::PROLOGUE_SIZE);
 
         // craft 8-byte payload as current timestamp (in milliseconds)
         let payload = time_provider();
@@ -241,7 +241,7 @@ impl NoiseUpgrader {
                 prologue_msg,
                 remote_public_key,
                 Some(&payload),
-                &mut client_noise_msg,
+                client_noise_msg,
             )
             .map_err(NoiseHandshakeError::BuildClientHandshakeMessageFailed)?;
 
diff --git a/network/src/noise/stream.rs b/network/src/noise/stream.rs
index 8abd563ec933c..345c702506633 100644
--- a/network/src/noise/stream.rs
+++ b/network/src/noise/stream.rs
@@ -89,7 +89,7 @@ impl<TSocket> NoiseStream<TSocket>
 where
     TSocket: AsyncRead + Unpin,
 {
-    fn poll_read(&mut self, mut context: &mut Context, buf: &mut [u8]) -> Poll<io::Result<usize>> {
+    fn poll_read(&mut self, context: &mut Context, buf: &mut [u8]) -> Poll<io::Result<usize>> {
         loop {
             trace!("NoiseStream ReadState::{:?}", self.read_state);
             match self.read_state {
@@ -104,7 +104,7 @@ where
                     ref mut offset,
                 } => {
                     match ready!(poll_read_u16frame_len(
-                        &mut context,
+                        context,
                         Pin::new(&mut self.socket),
                         buf,
                         offset
@@ -137,7 +137,7 @@ where
                     ref mut offset,
                 } => {
                     match ready!(poll_read_exact(
-                        &mut context,
+                        context,
                         Pin::new(&mut self.socket),
                         &mut self.buffers.read_buffer[..(frame_len as usize)],
                         offset
@@ -234,7 +234,7 @@ where
 {
     fn poll_write_or_flush(
         &mut self,
-        mut context: &mut Context,
+        context: &mut Context,
         buf: Option<&[u8]>,
     ) -> Poll<io::Result<Option<usize>>> {
         loop {
@@ -310,7 +310,7 @@ where
                     ref mut offset,
                 } => {
                     match ready!(poll_write_all(
-                        &mut context,
+                        context,
                         Pin::new(&mut self.socket),
                         buf,
                         offset
@@ -334,7 +334,7 @@ where
                     ref mut offset,
                 } => {
                     match ready!(poll_write_all(
-                        &mut context,
+                        context,
                         Pin::new(&mut self.socket),
                         &self.buffers.write_buffer[..(frame_len as usize)],
                         offset
@@ -351,7 +351,7 @@ where
                     }
                 }
                 WriteState::Flush => {
-                    ready!(Pin::new(&mut self.socket).poll_flush(&mut context))?;
+                    ready!(Pin::new(&mut self.socket).poll_flush(context))?;
                     self.write_state = WriteState::Init;
                 }
                 WriteState::Eof => return Poll::Ready(Err(io::ErrorKind::WriteZero.into())),
@@ -461,7 +461,7 @@ impl ::std::fmt::Debug for NoiseBuffers {
 
 /// Write an offset of a buffer to a socket, only returns Ready once done.
 fn poll_write_all<TSocket>(
-    mut context: &mut Context,
+    context: &mut Context,
     mut socket: Pin<&mut TSocket>,
     buf: &[u8],
     offset: &mut usize,
@@ -471,7 +471,7 @@ where
 {
     assert!(*offset <= buf.len());
     loop {
-        let n = ready!(socket.as_mut().poll_write(&mut context, &buf[*offset..]))?;
+        let n = ready!(socket.as_mut().poll_write(context, &buf[*offset..]))?;
         trace!("poll_write_all: wrote {}/{} bytes", *offset + n, buf.len());
         if n == 0 {
             return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
@@ -516,7 +516,7 @@ where
 /// It is possible that this function never completes,
 /// so a timeout needs to be set on the caller side.
 fn poll_read_exact<TSocket>(
-    mut context: &mut Context,
+    context: &mut Context,
     mut socket: Pin<&mut TSocket>,
     buf: &mut [u8],
     offset: &mut usize,
@@ -526,7 +526,7 @@ where
 {
     assert!(*offset <= buf.len());
     loop {
-        let n = ready!(socket.as_mut().poll_read(&mut context, &mut buf[*offset..]))?;
+        let n = ready!(socket.as_mut().poll_read(context, &mut buf[*offset..]))?;
         trace!("poll_read_exact: read {}/{} bytes", *offset + n, buf.len());
         if n == 0 {
             return Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()));
diff --git a/rust-toolchain b/rust-toolchain
index 43c989b55315f..bb120e876c620 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.56.1
+1.59.0
diff --git a/state-sync/inter-component/event-notifications/src/lib.rs b/state-sync/inter-component/event-notifications/src/lib.rs
index 1a71724179d49..0d716889218c3 100644
--- a/state-sync/inter-component/event-notifications/src/lib.rs
+++ b/state-sync/inter-component/event-notifications/src/lib.rs
@@ -123,7 +123,6 @@ impl EventSubscriptionService {
         // Create a new event subscription
         let subscription_id = self.get_new_subscription_id();
         let event_subscription = EventSubscription {
-            subscription_id,
             notification_sender,
             event_buffer: vec![],
         };
@@ -167,7 +166,6 @@ impl EventSubscriptionService {
         // Create a new reconfiguration subscription
         let subscription_id = self.get_new_subscription_id();
         let reconfig_subscription = ReconfigSubscription {
-            subscription_id,
             notification_sender,
         };
 
@@ -359,7 +357,6 @@ type SubscriptionId = u64;
 /// send the corresponding notifications and a buffer to hold pending events.
 #[derive(Debug)]
 struct EventSubscription {
-    pub subscription_id: SubscriptionId,
     pub event_buffer: Vec<ContractEvent>,
     pub notification_sender: channel::aptos_channel::Sender<(), EventNotification>,
 }
@@ -385,7 +382,6 @@ impl EventSubscription {
 /// corresponding notifications.
 #[derive(Debug)]
 struct ReconfigSubscription {
-    pub subscription_id: SubscriptionId,
     pub notification_sender: channel::aptos_channel::Sender<(), ReconfigNotification>,
 }
 
diff --git a/state-sync/state-sync-v1/src/request_manager.rs b/state-sync/state-sync-v1/src/request_manager.rs
index 5fa8aa64bc15c..83bc4675f7063 100644
--- a/state-sync/state-sync-v1/src/request_manager.rs
+++ b/state-sync/state-sync-v1/src/request_manager.rs
@@ -39,7 +39,6 @@ const STARTING_SCORE_PREFERRED: f64 = 100.0;
 /// Basic metadata about the chunk request.
 #[derive(Clone, Debug)]
 pub struct ChunkRequestInfo {
-    version: u64,
     first_request_time: SystemTime,
     last_request_time: SystemTime,
     multicast_level: NetworkId,
@@ -48,10 +47,9 @@ pub struct ChunkRequestInfo {
 }
 
 impl ChunkRequestInfo {
-    pub fn new(version: u64, peers: Vec<PeerNetworkId>, multicast_level: NetworkId) -> Self {
+    pub fn new(peers: Vec<PeerNetworkId>, multicast_level: NetworkId) -> Self {
         let now = SystemTime::now();
         Self {
-            version,
             first_request_time: now,
             last_request_time: now,
             multicast_level,
@@ -342,8 +340,7 @@ impl RequestManager {
             prev_request.last_request_time = now;
             prev_request.clone()
         } else {
-            let chunk_request_info =
-                ChunkRequestInfo::new(version, peers, self.multicast_network_level);
+            let chunk_request_info = ChunkRequestInfo::new(peers, self.multicast_network_level);
             self.requests.insert(version, chunk_request_info.clone());
             chunk_request_info
         }
diff --git a/state-sync/state-sync-v2/data-streaming-service/src/tests/utils.rs b/state-sync/state-sync-v2/data-streaming-service/src/tests/utils.rs
index 5f3bd9a14a989..9ca687b4fd42a 100644
--- a/state-sync/state-sync-v2/data-streaming-service/src/tests/utils.rs
+++ b/state-sync/state-sync-v2/data-streaming-service/src/tests/utils.rs
@@ -368,7 +368,7 @@ fn create_range_random_u64(min_value: u64, max_value: u64) -> u64 {
 
 /// Initializes the Aptos logger for tests
 pub fn initialize_logger() {
-    aptos_logger::AptosData::builder()
+    aptos_logger::Logger::builder()
         .is_async(false)
         .level(Level::Info)
         .build();
diff --git a/state-sync/state-sync-v2/state-sync-driver/src/bootstrapper.rs b/state-sync/state-sync-v2/state-sync-driver/src/bootstrapper.rs
index a92d0f64c99d5..bf399fa7c50cb 100644
--- a/state-sync/state-sync-v2/state-sync-driver/src/bootstrapper.rs
+++ b/state-sync/state-sync-v2/state-sync-driver/src/bootstrapper.rs
@@ -10,9 +10,9 @@ use crate::{
     utils,
     utils::SpeculativeStreamState,
 };
+use ::aptos_logger::*;
 use aptos_config::config::BootstrappingMode;
 use aptos_data_client::GlobalDataSummary;
-use aptos_logger::*;
 use aptos_types::{
     epoch_change::Verifier,
     epoch_state::EpochState,
diff --git a/state-sync/state-sync-v2/state-sync-driver/src/driver.rs b/state-sync/state-sync-v2/state-sync-driver/src/driver.rs
index 36a1c43f5544d..fb91404ab87cf 100644
--- a/state-sync/state-sync-v2/state-sync-driver/src/driver.rs
+++ b/state-sync/state-sync-v2/state-sync-driver/src/driver.rs
@@ -15,10 +15,10 @@ use crate::{
     storage_synchronizer::StorageSynchronizerInterface,
     utils,
 };
+use ::aptos_logger::*;
 use aptos_config::config::{RoleType, StateSyncDriverConfig};
 use aptos_data_client::AptosDataClient;
 use aptos_infallible::Mutex;
-use aptos_logger::*;
 use aptos_types::waypoint::Waypoint;
 use consensus_notifications::{
     ConsensusCommitNotification, ConsensusNotification, ConsensusSyncNotification,
diff --git a/state-sync/state-sync-v2/state-sync-driver/src/storage_synchronizer.rs b/state-sync/state-sync-v2/state-sync-driver/src/storage_synchronizer.rs
index f7eaa3892e685..a1cfb58e99c44 100644
--- a/state-sync/state-sync-v2/state-sync-driver/src/storage_synchronizer.rs
+++ b/state-sync/state-sync-v2/state-sync-driver/src/storage_synchronizer.rs
@@ -479,8 +479,7 @@ fn spawn_state_snapshot_receiver<ChunkExecutor: ChunkExecutorTrait + 'static>(
                                                 .unzip();
                                         let events = outputs
                                             .into_iter()
-                                            .map(|output| output.events().to_vec())
-                                            .flatten()
+                                            .flat_map(|output| output.events().to_vec())
                                             .collect::<Vec<_>>();
                                     let committed_transaction = CommittedTransactions {
                                             events,
diff --git a/state-sync/storage-service/server/src/lib.rs b/state-sync/storage-service/server/src/lib.rs
index e07d23627ef05..9f42ad53ac243 100644
--- a/state-sync/storage-service/server/src/lib.rs
+++ b/state-sync/storage-service/server/src/lib.rs
@@ -156,12 +156,11 @@ impl<T: StorageReaderInterface> StorageServiceServer<T> {
             // All handler methods are currently CPU-bound and synchronous
             // I/O-bound, so we want to spawn on the blocking thread pool to
             // avoid starving other async tasks on the same runtime.
-            let config = self.config;
             let storage = self.storage.clone();
             let cached_storage_server_summary = self.cached_storage_server_summary.clone();
             self.bounded_executor
                 .spawn_blocking(move || {
-                    let response = Handler::new(config, storage, cached_storage_server_summary)
+                    let response = Handler::new(storage, cached_storage_server_summary)
                         .call(protocol, request);
                     log_storage_response(&response);
                     response_sender.send(response);
@@ -205,19 +204,16 @@ fn refresh_cached_storage_summary<T: StorageReaderInterface>(
 /// request. We usually clone/create a new handler for every request.
 #[derive(Clone)]
 pub struct Handler<T> {
-    config: StorageServiceConfig,
     storage: T,
     cached_storage_server_summary: Arc<RwLock<StorageServerSummary>>,
 }
 
 impl<T: StorageReaderInterface> Handler<T> {
     pub fn new(
-        config: StorageServiceConfig,
         storage: T,
         cached_storage_server_summary: Arc<RwLock<StorageServerSummary>>,
     ) -> Self {
         Self {
-            config,
             storage,
             cached_storage_server_summary,
         }
diff --git a/state-sync/storage-service/server/src/tests.rs b/state-sync/storage-service/server/src/tests.rs
index 8931e784b1e97..247bfe784eef6 100644
--- a/state-sync/storage-service/server/src/tests.rs
+++ b/state-sync/storage-service/server/src/tests.rs
@@ -765,7 +765,7 @@ impl DbReader for MockDbReader {
 
 /// Initializes the Aptos logger for tests
 pub fn initialize_logger() {
-    aptos_logger::AptosData::builder()
+    aptos_logger::Logger::builder()
         .is_async(false)
         .level(Level::Debug)
         .build();
diff --git a/storage/aptosdb/src/lib.rs b/storage/aptosdb/src/lib.rs
index 407238fa79e73..17bcbe00e7bb6 100644
--- a/storage/aptosdb/src/lib.rs
+++ b/storage/aptosdb/src/lib.rs
@@ -83,14 +83,7 @@ use aptos_types::{
 use itertools::zip_eq;
 use once_cell::sync::Lazy;
 use schemadb::{ColumnFamilyName, Options, DB, DEFAULT_CF_NAME};
-use std::{
-    collections::HashMap,
-    iter::Iterator,
-    path::Path,
-    sync::{mpsc, Arc, Mutex},
-    thread::{self, JoinHandle},
-    time::{Duration, Instant},
-};
+use std::{collections::HashMap, iter::Iterator, path::Path, sync::Arc, time::Instant};
 use storage_interface::{DbReader, DbWriter, Order, StartupInfo, StateSnapshotReceiver, TreeState};
 
 const MAX_LIMIT: u64 = 5000;
@@ -134,7 +127,7 @@ static ROCKSDB_PROPERTY_MAP: Lazy<HashMap<&str, String>> = Lazy::new(|| {
         "rocksdb.block-cache-pinned-usage",
     ]
     .iter()
-    .map(|x| (*x, format!("aptos_{}", x.replace(".", "_"))))
+    .map(|x| (*x, format!("aptos_{}", x.replace('.', "_"))))
     .collect()
 });
 
@@ -167,48 +160,6 @@ fn update_rocksdb_properties(db: &DB) -> Result<()> {
     Ok(())
 }
 
-#[derive(Debug)]
-struct RocksdbPropertyReporter {
-    sender: Mutex<mpsc::Sender<()>>,
-    join_handle: Option<JoinHandle<()>>,
-}
-
-impl RocksdbPropertyReporter {
-    fn new(db: Arc<DB>) -> Self {
-        let (send, recv) = mpsc::channel();
-        let join_handle = Some(thread::spawn(move || loop {
-            if let Err(e) = update_rocksdb_properties(&db) {
-                warn!(
-                    error = ?e,
-                    "Updating rocksdb property failed."
-                );
-            }
-            // report rocksdb properties each 10 seconds
-            match recv.recv_timeout(Duration::from_secs(10)) {
-                Ok(_) => break,
-                Err(mpsc::RecvTimeoutError::Timeout) => (),
-                Err(mpsc::RecvTimeoutError::Disconnected) => break,
-            }
-        }));
-        Self {
-            sender: Mutex::new(send),
-            join_handle,
-        }
-    }
-}
-
-impl Drop for RocksdbPropertyReporter {
-    fn drop(&mut self) {
-        // Notify the property reporting thread to exit
-        self.sender.lock().unwrap().send(()).unwrap();
-        self.join_handle
-            .take()
-            .expect("Rocksdb property reporting thread must exist.")
-            .join()
-            .expect("Rocksdb property reporting thread should join peacefully.");
-    }
-}
-
 /// This holds a handle to the underlying DB responsible for physical storage and provides APIs for
 /// access to the core Aptos data structures.
 #[derive(Debug)]
@@ -219,7 +170,6 @@ pub struct AptosDB {
     state_store: Arc<StateStore>,
     event_store: Arc<EventStore>,
     system_store: Arc<SystemStore>,
-    rocksdb_property_reporter: RocksdbPropertyReporter,
     pruner: Option<Pruner>,
 }
 
@@ -258,7 +208,6 @@ impl AptosDB {
             state_store: Arc::new(StateStore::new(Arc::clone(&db))),
             transaction_store: Arc::clone(&transaction_store),
             system_store: Arc::clone(&system_store),
-            rocksdb_property_reporter: RocksdbPropertyReporter::new(Arc::clone(&db)),
             pruner: match storage_pruner_config {
                 NO_OP_STORAGE_PRUNER_CONFIG => None,
                 _ => Some(Pruner::new(
@@ -568,7 +517,7 @@ impl AptosDB {
         &self,
         txns_to_commit: &[TransactionToCommit],
         first_version: u64,
-        mut cs: &mut ChangeSet,
+        cs: &mut ChangeSet,
     ) -> Result<HashValue> {
         let last_version = first_version + txns_to_commit.len() as u64 - 1;
 
@@ -587,12 +536,8 @@ impl AptosDB {
                 .iter()
                 .map(|txn_to_commit| txn_to_commit.jf_node_hashes())
                 .collect::<Option<Vec<_>>>();
-            self.state_store.put_value_sets(
-                account_state_sets,
-                node_hashes,
-                first_version,
-                &mut cs,
-            )?;
+            self.state_store
+                .put_value_sets(account_state_sets, node_hashes, first_version, cs)?;
         }
 
         // Event updates. Gather event accumulator root hashes.
@@ -602,8 +547,7 @@ impl AptosDB {
                 .start_timer();
             zip_eq(first_version..=last_version, txns_to_commit)
                 .map(|(ver, txn_to_commit)| {
-                    self.event_store
-                        .put_events(ver, txn_to_commit.events(), &mut cs)
+                    self.event_store.put_events(ver, txn_to_commit.events(), cs)
                 })
                 .collect::<Result<Vec<_>>>()?;
         }
@@ -615,13 +559,10 @@ impl AptosDB {
             zip_eq(first_version..=last_version, txns_to_commit).try_for_each(
                 |(ver, txn_to_commit)| {
                     // Transaction updates. Gather transaction hashes.
-                    self.transaction_store.put_transaction(
-                        ver,
-                        txn_to_commit.transaction(),
-                        &mut cs,
-                    )?;
                     self.transaction_store
-                        .put_write_set(ver, txn_to_commit.write_set(), &mut cs)
+                        .put_transaction(ver, txn_to_commit.transaction(), cs)?;
+                    self.transaction_store
+                        .put_write_set(ver, txn_to_commit.write_set(), cs)
                 },
             )?;
             // Transaction accumulator updates. Get result root hash.
@@ -631,7 +572,7 @@ impl AptosDB {
                 .cloned()
                 .collect();
             self.ledger_store
-                .put_transaction_infos(first_version, &txn_infos, &mut cs)?
+                .put_transaction_infos(first_version, &txn_infos, cs)?
         };
 
         Ok(new_root_hash)
diff --git a/storage/backup/backup-cli/src/backup_types/tests.rs b/storage/backup/backup-cli/src/backup_types/tests.rs
index fe41d6c1a01a1..eb744ad2b3a32 100644
--- a/storage/backup/backup-cli/src/backup_types/tests.rs
+++ b/storage/backup/backup-cli/src/backup_types/tests.rs
@@ -34,7 +34,6 @@ struct TestData {
     txn_start_ver: Version,
     state_snapshot_ver: Option<Version>,
     target_ver: Version,
-    latest_ver: Version,
 }
 
 fn test_data_strategy() -> impl Strategy<Value = TestData> {
@@ -56,7 +55,6 @@ fn test_data_strategy() -> impl Strategy<Value = TestData> {
                 txn_start_ver,
                 state_snapshot_ver,
                 target_ver,
-                latest_ver,
             },
         )
 }
diff --git a/storage/backup/backup-cli/src/backup_types/transaction/tests.rs b/storage/backup/backup-cli/src/backup_types/transaction/tests.rs
index 9b319ae9b9cdb..19da26dbaf43c 100644
--- a/storage/backup/backup-cli/src/backup_types/transaction/tests.rs
+++ b/storage/backup/backup-cli/src/backup_types/transaction/tests.rs
@@ -40,8 +40,7 @@ fn end_to_end() {
     assert_eq!(latest_version as usize + 1, total_txns);
     let txns = blocks
         .iter()
-        .map(|(txns, _li)| txns)
-        .flatten()
+        .flat_map(|(txns, _li)| txns)
         .map(|txn_to_commit| txn_to_commit.transaction())
         .collect::<Vec<_>>();
     let max_chunk_size = txns
@@ -128,11 +127,10 @@ fn end_to_end() {
         recovered_transactions.events.unwrap(),
         blocks
             .iter()
-            .map(|(txns, _li)| {
+            .flat_map(|(txns, _li)| {
                 txns.iter()
                     .map(|txn_to_commit| txn_to_commit.events().to_vec())
             })
-            .flatten()
             .skip(first_ver_to_backup as usize)
             .take(num_txns_to_restore)
             .collect::<Vec<_>>()
diff --git a/storage/inspector/src/main.rs b/storage/inspector/src/main.rs
index 4d39d14b3d1a7..97ea9db189e9c 100644
--- a/storage/inspector/src/main.rs
+++ b/storage/inspector/src/main.rs
@@ -155,7 +155,7 @@ fn list_accounts(db: &AptosDB) {
 }
 
 fn main() {
-    ::aptos_logger::AptosData::builder().build();
+    ::aptos_logger::Logger::builder().build();
 
     let opt = Opt::from_args();
 
diff --git a/storage/scratchpad/src/sparse_merkle/test_utils/naive_smt.rs b/storage/scratchpad/src/sparse_merkle/test_utils/naive_smt.rs
index 33320702727b1..b7f851a88b0d6 100644
--- a/storage/scratchpad/src/sparse_merkle/test_utils/naive_smt.rs
+++ b/storage/scratchpad/src/sparse_merkle/test_utils/naive_smt.rs
@@ -21,7 +21,7 @@ impl<'a> NaiveSubTree<'a> {
     fn get_proof(
         &'a self,
         key: &HashValue,
-        mut cache: &mut Cache,
+        cache: &mut Cache,
     ) -> (Option<SparseMerkleLeafNode>, Vec<HashValue>) {
         if self.is_empty() {
             (None, Vec::new())
@@ -34,12 +34,12 @@ impl<'a> NaiveSubTree<'a> {
         } else {
             let (left, right) = self.children();
             if key.bit(self.depth) {
-                let (ret_leaf, mut ret_siblings) = right.get_proof(key, &mut cache);
-                ret_siblings.push(left.get_hash(&mut cache));
+                let (ret_leaf, mut ret_siblings) = right.get_proof(key, cache);
+                ret_siblings.push(left.get_hash(cache));
                 (ret_leaf, ret_siblings)
             } else {
-                let (ret_leaf, mut ret_siblings) = left.get_proof(key, &mut cache);
-                ret_siblings.push(right.get_hash(&mut cache));
+                let (ret_leaf, mut ret_siblings) = left.get_proof(key, cache);
+                ret_siblings.push(right.get_hash(cache));
                 (ret_leaf, ret_siblings)
             }
         }
@@ -49,7 +49,7 @@ impl<'a> NaiveSubTree<'a> {
         self.leaves.is_empty()
     }
 
-    fn get_hash(&self, mut cache: &mut Cache) -> HashValue {
+    fn get_hash(&self, cache: &mut Cache) -> HashValue {
         if self.leaves.is_empty() {
             return *SPARSE_MERKLE_PLACEHOLDER_HASH;
         }
@@ -64,22 +64,21 @@ impl<'a> NaiveSubTree<'a> {
         match cache.get(&position) {
             Some(hash) => *hash,
             None => {
-                let hash = self.get_hash_uncached(&mut cache);
+                let hash = self.get_hash_uncached(cache);
                 cache.insert(position, hash);
                 hash
             }
         }
     }
 
-    fn get_hash_uncached(&self, mut cache: &mut Cache) -> HashValue {
+    fn get_hash_uncached(&self, cache: &mut Cache) -> HashValue {
         assert!(!self.leaves.is_empty());
         if self.leaves.len() == 1 {
             let only_leaf = self.leaves[0];
             SparseMerkleLeafNode::new(only_leaf.0, only_leaf.1).hash()
         } else {
             let (left, right) = self.children();
-            SparseMerkleInternalNode::new(left.get_hash(&mut cache), right.get_hash(&mut cache))
-                .hash()
+            SparseMerkleInternalNode::new(left.get_hash(cache), right.get_hash(cache)).hash()
         }
     }
 
diff --git a/testsuite/aptos-fuzzer/src/commands.rs b/testsuite/aptos-fuzzer/src/commands.rs
index 72eae4588d78d..51a70b2b497f3 100644
--- a/testsuite/aptos-fuzzer/src/commands.rs
+++ b/testsuite/aptos-fuzzer/src/commands.rs
@@ -69,7 +69,7 @@ pub fn fuzz_target(
     // Do a bit of arg parsing -- look for a "--" and insert the target and corpus directory
     // before that.
     let dash_dash_pos = args.iter().position(|x| x == "--");
-    let splice_pos = dash_dash_pos.unwrap_or_else(|| args.len());
+    let splice_pos = dash_dash_pos.unwrap_or(args.len());
     args.splice(
         splice_pos..splice_pos,
         vec![FUZZ_RUNNER.into(), corpus_dir.into()],
diff --git a/testsuite/forge-cli/src/main.rs b/testsuite/forge-cli/src/main.rs
index a4e4b9e9969ea..387b525eef34d 100644
--- a/testsuite/forge-cli/src/main.rs
+++ b/testsuite/forge-cli/src/main.rs
@@ -32,11 +32,6 @@ struct Args {
     suite: Option<String>,
     #[structopt(long, multiple = true)]
     changelog: Option<Vec<String>>,
-    #[structopt(
-        long,
-        help = "Whether transactions should be submitted to validators or full nodes"
-    )]
-    pub emit_to_validator: Option<bool>,
 
     // subcommand groups
     #[structopt(flatten)]
@@ -63,14 +58,7 @@ enum OperatorCommand {
 }
 
 #[derive(StructOpt, Debug)]
-struct LocalSwarm {
-    #[structopt(
-        long,
-        help = "Time to run --emit-tx for in seconds",
-        default_value = "60"
-    )]
-    duration: u64,
-}
+struct LocalSwarm {}
 
 #[derive(StructOpt, Debug)]
 struct K8sSwarm {
diff --git a/testsuite/forge/src/backend/k8s/cluster_helper.rs b/testsuite/forge/src/backend/k8s/cluster_helper.rs
index d22c276be8866..4f5884c27e364 100644
--- a/testsuite/forge/src/backend/k8s/cluster_helper.rs
+++ b/testsuite/forge/src/backend/k8s/cluster_helper.rs
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{get_validators, k8s_retry_strategy, nodes_healthcheck, Result};
+use ::aptos_logger::*;
 use anyhow::{bail, format_err};
-use aptos_logger::*;
 use futures::future::try_join_all;
 use hyper::{Client, Uri};
 use hyper_proxy::{Intercept, Proxy, ProxyConnector};
@@ -393,13 +393,13 @@ fn create_eks_client(auth_with_k8s_env: bool) -> Result<EksClient> {
     let connector = HttpsConnector::new();
     let http_connector: hyper_proxy::ProxyConnector<
         hyper_tls::HttpsConnector<hyper::client::HttpConnector>,
-    >;
-    if let Ok(proxy_url) = std::env::var("HTTP_PROXY") {
+    > = if let Ok(proxy_url) = std::env::var("HTTP_PROXY") {
         let proxy = Proxy::new(Intercept::All, proxy_url.parse::<Uri>()?);
-        http_connector = ProxyConnector::from_proxy(connector, proxy)?;
+        ProxyConnector::from_proxy(connector, proxy)
     } else {
-        http_connector = ProxyConnector::new(connector)?;
-    }
+        ProxyConnector::new(connector)
+    }?;
+
     let mut hyper_builder = Client::builder();
     // disabling due to connection closed issue
     hyper_builder.pool_max_idle_per_host(0);
@@ -604,7 +604,7 @@ pub fn scale_sts_replica(sts_name: &str, replica_num: u64) -> Result<()> {
     let scale_sts_args = [
         "scale",
         "sts",
-        &sts_name.to_string(),
+        sts_name,
         &format!("--replicas={}", replica_num),
     ];
     println!("{:?}", scale_sts_args);
diff --git a/testsuite/forge/src/backend/k8s/swarm.rs b/testsuite/forge/src/backend/k8s/swarm.rs
index 760033c53da5c..bfebec5e36e67 100644
--- a/testsuite/forge/src/backend/k8s/swarm.rs
+++ b/testsuite/forge/src/backend/k8s/swarm.rs
@@ -5,9 +5,9 @@ use crate::{
     backend::k8s::node::K8sNode, create_k8s_client, query_sequence_numbers, remove_helm_release,
     set_validator_image_tag, ChainInfo, FullNode, Node, Result, Swarm, Validator, Version,
 };
+use ::aptos_logger::*;
 use anyhow::{anyhow, bail, format_err};
 use aptos_config::config::NodeConfig;
-use aptos_logger::*;
 use aptos_sdk::{
     crypto::ed25519::Ed25519PrivateKey,
     types::{
diff --git a/testsuite/forge/src/backend/local/mod.rs b/testsuite/forge/src/backend/local/mod.rs
index 4a3f14f280f35..60cbc2e588514 100644
--- a/testsuite/forge/src/backend/local/mod.rs
+++ b/testsuite/forge/src/backend/local/mod.rs
@@ -19,18 +19,13 @@ pub use swarm::{LocalSwarm, LocalSwarmBuilder, SwarmDirectory};
 
 #[derive(Clone, Debug)]
 pub struct LocalVersion {
-    revision: String,
     bin: PathBuf,
     version: Version,
 }
 
 impl LocalVersion {
-    pub fn new(revision: String, bin: PathBuf, version: Version) -> Self {
-        Self {
-            revision,
-            bin,
-            version,
-        }
+    pub fn new(bin: PathBuf, version: Version) -> Self {
+        Self { bin, version }
     }
 
     pub fn bin(&self) -> &Path {
@@ -56,12 +51,8 @@ impl LocalFactory {
     pub fn from_workspace() -> Result<Self> {
         let mut versions = HashMap::new();
         let new_version = cargo::get_aptos_node_binary_from_worktree().map(|(revision, bin)| {
-            let version = Version::new(usize::max_value(), revision.clone());
-            LocalVersion {
-                revision,
-                bin,
-                version,
-            }
+            let version = Version::new(usize::max_value(), revision);
+            LocalVersion { bin, version }
         })?;
 
         versions.insert(new_version.version.clone(), new_version);
@@ -72,12 +63,8 @@ impl LocalFactory {
         let mut versions = HashMap::new();
         let new_version =
             cargo::get_aptos_node_binary_at_revision(revision).map(|(revision, bin)| {
-                let version = Version::new(usize::max_value(), revision.clone());
-                LocalVersion {
-                    revision,
-                    bin,
-                    version,
-                }
+                let version = Version::new(usize::max_value(), revision);
+                LocalVersion { bin, version }
             })?;
 
         versions.insert(new_version.version.clone(), new_version);
@@ -86,21 +73,13 @@ impl LocalFactory {
 
     pub fn with_revision_and_workspace(revision: &str) -> Result<Self> {
         let workspace = cargo::get_aptos_node_binary_from_worktree().map(|(revision, bin)| {
-            let version = Version::new(usize::max_value(), revision.clone());
-            LocalVersion {
-                revision,
-                bin,
-                version,
-            }
+            let version = Version::new(usize::max_value(), revision);
+            LocalVersion { bin, version }
         })?;
         let revision =
             cargo::get_aptos_node_binary_at_revision(revision).map(|(revision, bin)| {
-                let version = Version::new(usize::min_value(), revision.clone());
-                LocalVersion {
-                    revision,
-                    bin,
-                    version,
-                }
+                let version = Version::new(usize::min_value(), revision);
+                LocalVersion { bin, version }
             })?;
 
         let mut versions = HashMap::new();
diff --git a/testsuite/forge/src/interface/aptos.rs b/testsuite/forge/src/interface/aptos.rs
index 2b075d203c8e8..ca1885cc56758 100644
--- a/testsuite/forge/src/interface/aptos.rs
+++ b/testsuite/forge/src/interface/aptos.rs
@@ -88,7 +88,7 @@ impl<'t> AptosContext<'t> {
     }
 
     pub fn root_account(&mut self) -> &mut LocalAccount {
-        &mut self.public_info.root_account
+        self.public_info.root_account
     }
 }
 
diff --git a/testsuite/forge/src/runner.rs b/testsuite/forge/src/runner.rs
index 7ae4d3ed9f726..07142a73d0457 100644
--- a/testsuite/forge/src/runner.rs
+++ b/testsuite/forge/src/runner.rs
@@ -23,13 +23,16 @@ pub struct Options {
     #[structopt(long = "exact")]
     /// Exactly match filters rather than by substring
     filter_exact: bool,
+    #[allow(dead_code)]
     #[structopt(long, default_value = "1", env = "RUST_TEST_THREADS")]
     /// NO-OP: unsupported option, exists for compatibility with the default test harness
     /// Number of threads used for running tests in parallel
     test_threads: NonZeroUsize,
+    #[allow(dead_code)]
     #[structopt(short = "q", long)]
-    /// Output minimal information
+    /// NO-OP: unsupported option, exists for compatibility with the default test harness
     quiet: bool,
+    #[allow(dead_code)]
     #[structopt(long)]
     /// NO-OP: unsupported option, exists for compatibility with the default test harness
     nocapture: bool,
@@ -48,11 +51,13 @@ pub struct Options {
     ///   (json is unsupported, exists for compatibility with the default test harness)
     #[structopt(long, possible_values = &Format::variants(), default_value, case_insensitive = true)]
     format: Format,
+    #[allow(dead_code)]
     #[structopt(short = "Z")]
     /// NO-OP: unsupported option, exists for compatibility with the default test harness
     /// -Z unstable-options Enable nightly-only flags:
     ///                     unstable-options = Allow use of experimental features
     z_unstable_options: Option<String>,
+    #[allow(dead_code)]
     #[structopt(long)]
     /// NO-OP: unsupported option, exists for compatibility with the default test harness
     /// Show captured stdout of successful tests
diff --git a/testsuite/generate-format/tests/detect_format_change.rs b/testsuite/generate-format/tests/detect_format_change.rs
index 7eea15742a433..18ad987bf51d0 100644
--- a/testsuite/generate-format/tests/detect_format_change.rs
+++ b/testsuite/generate-format/tests/detect_format_change.rs
@@ -26,7 +26,7 @@ fn analyze_serde_formats() {
                 generate_format::lint_bcs_format(&value),
                 Ok(()),
                 "In corpus {}: lint error while analyzing {}",
-                corpus.to_string(),
+                corpus,
                 key
             );
 
@@ -39,7 +39,7 @@ fn analyze_serde_formats() {
                     &value,
                     "Type {} in corpus {} differs with previous definition in another corpus: {:?} vs {:?}",
                     key,
-                    corpus.to_string(),
+                    corpus,
                     e.get(),
                     &value,
                 ),
diff --git a/types/src/on_chain_config/consensus_config.rs b/types/src/on_chain_config/consensus_config.rs
index a53a0a870256d..61727b8c0aa88 100644
--- a/types/src/on_chain_config/consensus_config.rs
+++ b/types/src/on_chain_config/consensus_config.rs
@@ -60,17 +60,11 @@ impl Default for OnChainConsensusConfig {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
 pub struct ConsensusConfigV1 {
     pub two_chain: bool,
 }
 
-impl Default for ConsensusConfigV1 {
-    fn default() -> Self {
-        Self { two_chain: false }
-    }
-}
-
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ConsensusConfigV2 {
     pub two_chain: bool,