diff --git a/keyserver/addons/rust-node-addon/build.rs b/keyserver/addons/rust-node-addon/build.rs
index 14d4c32e5..6c6dfd52a 100644
--- a/keyserver/addons/rust-node-addon/build.rs
+++ b/keyserver/addons/rust-node-addon/build.rs
@@ -1,50 +1,49 @@
 extern crate napi_build;
 
 use regex::Regex;
 
 use std::env;
 use std::fs;
 use std::path::Path;
 
 fn main() {
   napi_build::setup();
 
   const VERSIONS_JS_PATH: &str = "../../../lib/facts/version.js";
   println!("cargo:rerun-if-changed={}", VERSIONS_JS_PATH);
   let js_path = Path::new(VERSIONS_JS_PATH);
 
-  let content =
-    fs::read_to_string(&js_path).expect("Failed to read version.js");
+  let content = fs::read_to_string(js_path).expect("Failed to read version.js");
 
   let version_line = content
     .lines()
     .find(|line| line.contains("webAndKeyserverCodeVersion"))
     .expect("Failed to find webAndKeyserverCodeVersion line");
 
   // Find a sequence in the input string that starts with
   // 'webAndKeyserverCodeVersion', followed by any number of whitespace
   // characters, an equals sign, any number of additional whitespace characters,
   // a series of one or more digits (and capture these digits), and finally a
   // semicolon.
   let re = Regex::new(r"webAndKeyserverCodeVersion\s*=\s*(\d+);").unwrap();
   let version: u64 = re
-    .captures(&version_line)
+    .captures(version_line)
     .and_then(|cap| cap.get(1))
     .map_or_else(
       || panic!("Failed to capture version number"),
       |m| {
         m.as_str()
           .parse::<u64>()
           .expect("Failed to parse version number")
       },
     );
 
   let out_dir = env::var("OUT_DIR").unwrap();
   let rust_path = Path::new(&out_dir).join("version.rs");
 
   fs::write(
-    &rust_path,
+    rust_path,
     format!("pub const CODE_VERSION: u64 = {};", version),
   )
   .expect("Failed to write version.rs");
 }
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/login.rs b/keyserver/addons/rust-node-addon/src/identity_client/login.rs
index 9cbbfe190..0a057f52b 100644
--- a/keyserver/addons/rust-node-addon/src/identity_client/login.rs
+++ b/keyserver/addons/rust-node-addon/src/identity_client/login.rs
@@ -1,86 +1,86 @@
 use super::*;
 
 use comm_opaque2::client::Login;
 use grpc_clients::identity::protos::unauthenticated::{
   OpaqueLoginFinishRequest, OpaqueLoginStartRequest,
 };
 use tracing::debug;
 
 #[napi]
 #[instrument(skip_all)]
 pub async fn login_user(
   username: String,
   password: String,
   signed_identity_keys_blob: SignedIdentityKeysBlob,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
 ) -> Result<UserLoginInfo> {
   debug!("Attempting to login user: {}", username);
 
   // Set up the gRPC client that will be used to talk to the Identity service
   let mut identity_client = get_identity_client_service_channel().await?;
 
   // Start OPAQUE registration and send initial registration request
   let mut client_login = Login::new();
   let opaque_login_request = client_login
     .start(&password)
     .map_err(|_| Error::from_reason("Failed to create opaque login request"))?;
 
   let login_start_request = OpaqueLoginStartRequest {
     opaque_login_request,
-    username: username,
+    username,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: signed_identity_keys_blob.payload,
         payload_signature: signed_identity_keys_blob.signature,
         social_proof: None,
       }),
       content_upload: Some(PreKey {
         pre_key: content_prekey,
         pre_key_signature: content_prekey_signature,
       }),
       notif_upload: Some(PreKey {
         pre_key: notif_prekey,
         pre_key_signature: notif_prekey_signature,
       }),
       one_time_content_prekeys: content_one_time_keys,
       one_time_notif_prekeys: notif_one_time_keys,
       device_type: DeviceType::Keyserver.into(),
     }),
   };
 
   debug!("Starting login to identity service");
   let login_start_response = identity_client
     .login_password_user_start(login_start_request)
     .await
     .map_err(handle_grpc_error)?
     .into_inner();
 
   debug!("Received login response from identity service");
   let opaque_login_upload = client_login
     .finish(&login_start_response.opaque_login_response)
     .map_err(|_| Error::from_reason("Failed to finish opaque login request"))?;
   let login_finish_request = OpaqueLoginFinishRequest {
     session_id: login_start_response.session_id,
     opaque_login_upload,
   };
 
   debug!("Attempting to finalize opaque login exchange with identity service");
   let login_finish_response = identity_client
     .login_password_user_finish(login_finish_request)
     .await
     .map_err(handle_grpc_error)?
     .into_inner();
 
   debug!("Finished login with identity service");
   let user_info = UserLoginInfo {
     user_id: login_finish_response.user_id,
     access_token: login_finish_response.access_token,
   };
 
   Ok(user_info)
 }