update to rust 1.59 and delete all the dead code

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,
         }
     }

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;
     });

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);

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
 }
 

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));
     }

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},

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)

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![

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()
     }
 

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
 }
 

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,

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,

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
 }
 

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

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))
             })?;
         }
 

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()

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,
                 )));
             }
         };

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 {

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 {

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?;

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)?;

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(_) => {

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);

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)

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]);

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]

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);
         }
     }
 }