diff --git a/shared/comm-opaque2/src/client/login.rs b/shared/comm-opaque2/src/client/login.rs
index b5b45af88..7fad897e2 100644
--- a/shared/comm-opaque2/src/client/login.rs
+++ b/shared/comm-opaque2/src/client/login.rs
@@ -1,72 +1,75 @@
 use opaque_ke::{
   errors::ProtocolError, ClientLogin, ClientLoginFinishParameters,
   CredentialResponse,
 };
 use rand::rngs::OsRng;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 use crate::{error::OpaqueError, Cipher};
 
 #[wasm_bindgen]
 pub struct Login {
   state: Option<ClientLogin<Cipher>>,
   password: Option<String>,
   rng: OsRng,
   export_key: Option<Vec<u8>>,
   session_key: Option<Vec<u8>>,
 }
 
 #[wasm_bindgen]
 impl Login {
   #[wasm_bindgen(constructor)]
   pub fn new() -> Login {
     Login {
       state: None,
       password: None,
       rng: OsRng,
       session_key: None,
       export_key: None,
     }
   }
 
   pub fn start(&mut self, password: &str) -> Result<Vec<u8>, OpaqueError> {
     let client_start_result =
       ClientLogin::<Cipher>::start(&mut self.rng, password.as_bytes())?;
     self.state = Some(client_start_result.state);
     self.password = Some(password.to_string());
     Ok(client_start_result.message.serialize().to_vec())
   }
 
   pub fn finish(
     &mut self,
     response_payload: &[u8],
   ) -> Result<Vec<u8>, OpaqueError> {
     let response = CredentialResponse::deserialize(response_payload)?;
     let password = self
       .password
       .take()
-      .ok_or_else(|| ProtocolError::InvalidLoginError)?;
-    let state = self
-      .state
-      .take()
-      .ok_or_else(|| ProtocolError::InvalidLoginError)?;
+      .ok_or(ProtocolError::InvalidLoginError)?;
+    let state = self.state.take().ok_or(ProtocolError::InvalidLoginError)?;
     let result = state.finish(
       password.as_bytes(),
       response,
       ClientLoginFinishParameters::default(),
     )?;
 
     self.session_key = Some(result.session_key.to_vec());
     self.export_key = Some(result.export_key.to_vec());
 
     Ok(result.message.serialize().to_vec())
   }
 
   #[wasm_bindgen(getter)]
   pub fn session_key(&self) -> Result<Vec<u8>, OpaqueError> {
     match &self.session_key {
       Some(v) => Ok(v.clone()),
       None => Err(ProtocolError::InvalidLoginError.into()),
     }
   }
 }
+
+impl Default for Login {
+  fn default() -> Self {
+    Self::new()
+  }
+}
diff --git a/shared/comm-opaque2/src/client/register.rs b/shared/comm-opaque2/src/client/register.rs
index 2c1a1b3fa..00a2c27e3 100644
--- a/shared/comm-opaque2/src/client/register.rs
+++ b/shared/comm-opaque2/src/client/register.rs
@@ -1,57 +1,60 @@
 use opaque_ke::{
   errors::ProtocolError, ClientRegistration,
   ClientRegistrationFinishParameters, RegistrationResponse,
 };
 use rand::rngs::OsRng;
 use wasm_bindgen::prelude::*;
 
 use crate::error::OpaqueError;
 use crate::Cipher;
 
 #[wasm_bindgen]
 pub struct Registration {
   state: Option<ClientRegistration<Cipher>>,
   rng: OsRng,
   export_key: Option<Vec<u8>>,
 }
 
 #[wasm_bindgen]
 impl Registration {
   #[wasm_bindgen(constructor)]
   pub fn new() -> Registration {
     Registration {
       state: None,
       rng: OsRng,
       export_key: None,
     }
   }
 
   pub fn start(&mut self, password: &str) -> Result<Vec<u8>, OpaqueError> {
     let result =
       ClientRegistration::<Cipher>::start(&mut self.rng, password.as_bytes())?;
     self.state = Some(result.state);
     Ok(result.message.serialize().to_vec())
   }
 
   pub fn finish(
     &mut self,
     password: &str,
     response_payload: &[u8],
   ) -> Result<Vec<u8>, OpaqueError> {
     let response = RegistrationResponse::deserialize(response_payload)?;
-    let state = self
-      .state
-      .take()
-      .ok_or_else(|| ProtocolError::InvalidLoginError)?;
+    let state = self.state.take().ok_or(ProtocolError::InvalidLoginError)?;
     let result = state.finish(
       &mut self.rng,
       password.as_bytes(),
       response,
       ClientRegistrationFinishParameters::default(),
     )?;
 
     self.export_key = Some(result.export_key.to_vec());
 
     Ok(result.message.serialize().to_vec())
   }
 }
+
+impl Default for Registration {
+  fn default() -> Self {
+    Self::new()
+  }
+}
diff --git a/shared/comm-opaque2/src/error.rs b/shared/comm-opaque2/src/error.rs
index 1a0157148..9e3e0ff4d 100644
--- a/shared/comm-opaque2/src/error.rs
+++ b/shared/comm-opaque2/src/error.rs
@@ -1,47 +1,47 @@
 use opaque_ke::errors::ProtocolError;
 use std::ops::Deref;
 use wasm_bindgen::{JsError, JsValue};
 
 /// Due to Rust's orphan rules, we cannot directly bridge
 /// opaque_ke::errors::ProtocolError to wasm_bindgen::JsValue. Instead we
 /// must define our own type, and add the impl's ourselves
 #[derive(Debug)]
 pub struct OpaqueError(ProtocolError);
 
-impl Into<JsValue> for OpaqueError {
-  fn into(self) -> JsValue {
-    JsValue::from(protocol_error_to_js_error(self.0))
+impl From<OpaqueError> for JsValue {
+  fn from(value: OpaqueError) -> Self {
+    Self::from(protocol_error_to_js_error(value.0))
   }
 }
 
-impl Into<ProtocolError> for OpaqueError {
-  fn into(self) -> ProtocolError {
-    self.0
+impl From<OpaqueError> for ProtocolError {
+  fn from(value: OpaqueError) -> Self {
+    value.0
   }
 }
 
 impl From<ProtocolError> for OpaqueError {
   fn from(error: ProtocolError) -> OpaqueError {
     OpaqueError(error)
   }
 }
 
 impl Deref for OpaqueError {
   type Target = ProtocolError;
 
   fn deref(&self) -> &Self::Target {
     &self.0
   }
 }
 
 fn protocol_error_to_js_error(error: ProtocolError) -> JsError {
   match error {
     ProtocolError::IdentityGroupElementError => JsError::new("server error"),
     ProtocolError::InvalidLoginError => JsError::new("login failed"),
     ProtocolError::LibraryError(_) => JsError::new("internal error"),
     ProtocolError::ReflectedValueError => {
       JsError::new("invalid server response")
     }
     ProtocolError::SerializationError => JsError::new("invalid argument"),
   }
 }
diff --git a/shared/comm-opaque2/src/lib.rs b/shared/comm-opaque2/src/lib.rs
index 35fc6a345..44cb1024c 100644
--- a/shared/comm-opaque2/src/lib.rs
+++ b/shared/comm-opaque2/src/lib.rs
@@ -1,58 +1,58 @@
 pub mod client;
 pub mod error;
 pub mod grpc;
 pub mod opaque;
 pub mod server;
 
 pub use crate::opaque::Cipher;
 pub use opaque_ke;
 pub use opaque_ke::errors::ProtocolError;
 pub use opaque_ke::ServerSetup;
 
 #[test]
 pub fn test_register_and_login() {
   use rand::rngs::OsRng;
 
   let pass = "test";
   let username = "alice";
 
   let server_setup = opaque_ke::ServerSetup::<Cipher>::new(&mut OsRng);
 
   // Register user
   let mut client_register = client::Registration::new();
   let client_message = client_register.start(pass).unwrap();
 
-  let mut server_register = server::Registration::new();
+  let server_register = server::Registration::new();
   let server_response = server_register
     .start(&server_setup, &client_message, username.as_bytes())
     .unwrap();
 
   let client_upload = client_register.finish(pass, &server_response).unwrap();
 
   // These bytes are the used to validate future login sessions, normally it
   // would saved to a database or other data store
   let password_file_bytes = server_register.finish(&client_upload).unwrap();
 
   // Login user
   let mut client_login = client::Login::new();
   let client_request = client_login.start(pass).unwrap();
 
   let mut server_login = server::Login::new();
   let server_response = server_login
     .start(
       &server_setup,
       &password_file_bytes,
       &client_request,
       username.as_bytes(),
     )
     .unwrap();
 
   let client_upload = client_login.finish(&server_response).unwrap();
 
   server_login.finish(&client_upload).unwrap();
 
   assert_eq!(
     client_login.session_key().unwrap(),
     server_login.session_key.unwrap()
   );
 }
diff --git a/shared/comm-opaque2/src/server/login.rs b/shared/comm-opaque2/src/server/login.rs
index 22a9005c6..53f7ee227 100644
--- a/shared/comm-opaque2/src/server/login.rs
+++ b/shared/comm-opaque2/src/server/login.rs
@@ -1,66 +1,69 @@
 use opaque_ke::{errors::ProtocolError, ServerRegistration};
 use opaque_ke::{
   CredentialFinalization, CredentialRequest, ServerLogin,
   ServerLoginStartParameters, ServerSetup,
 };
 use rand::rngs::OsRng;
 use serde::{Deserialize, Serialize};
 
 use crate::Cipher;
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct Login {
   state: Option<ServerLogin<Cipher>>,
   #[serde(default = "OsRng::default", skip)]
   rng: OsRng,
   pub session_key: Option<Vec<u8>>,
 }
 
 impl Login {
   pub fn new() -> Login {
     Login {
       state: None,
       rng: OsRng,
       session_key: None,
     }
   }
 
   pub fn start(
     &mut self,
     server_setup: &ServerSetup<Cipher>,
     password_file_bytes: &[u8],
     credential_request: &[u8],
     credential_identifier: &[u8],
   ) -> Result<Vec<u8>, ProtocolError> {
     let password_file = ServerRegistration::deserialize(password_file_bytes)?;
     let credential_request =
       CredentialRequest::deserialize(credential_request)?;
     let result = ServerLogin::start(
       &mut self.rng,
       server_setup,
       Some(password_file),
       credential_request,
       credential_identifier,
       ServerLoginStartParameters::default(),
     )?;
     self.state = Some(result.state);
 
     Ok(result.message.serialize().to_vec())
   }
 
   pub fn finish(
     &mut self,
     response_payload: &[u8],
   ) -> Result<(), ProtocolError> {
     let finalization_payload =
       CredentialFinalization::deserialize(response_payload)?;
 
-    let state = self
-      .state
-      .take()
-      .ok_or_else(|| ProtocolError::InvalidLoginError)?;
+    let state = self.state.take().ok_or(ProtocolError::InvalidLoginError)?;
     let result = state.finish(finalization_payload)?;
     self.session_key = Some(result.session_key.to_vec());
     Ok(())
   }
 }
+
+impl Default for Login {
+  fn default() -> Self {
+    Self::new()
+  }
+}
diff --git a/shared/comm-opaque2/src/server/register.rs b/shared/comm-opaque2/src/server/register.rs
index 865332b88..dbabf007e 100644
--- a/shared/comm-opaque2/src/server/register.rs
+++ b/shared/comm-opaque2/src/server/register.rs
@@ -1,40 +1,46 @@
 use opaque_ke::{errors::ProtocolError, ServerRegistration};
 use opaque_ke::{RegistrationRequest, RegistrationUpload, ServerSetup};
 
 use crate::Cipher;
 
 pub struct Registration {}
 
 impl Registration {
   pub fn new() -> Registration {
     Registration {}
   }
 
   pub fn start(
     &self,
     server_setup: &ServerSetup<Cipher>,
     payload: &[u8],
     credential_identifier: &[u8],
   ) -> Result<Vec<u8>, ProtocolError> {
     let upload = RegistrationRequest::deserialize(payload)?;
     let result = ServerRegistration::<Cipher>::start(
       server_setup,
       upload,
       credential_identifier,
     )?;
     Ok(result.message.serialize().to_vec())
   }
 
   pub fn finish(
     &self,
     response_payload: &[u8],
   ) -> Result<Vec<u8>, ProtocolError> {
     let upload_payload =
       RegistrationUpload::<Cipher>::deserialize(response_payload)?;
     Ok(
       ServerRegistration::finish(upload_payload)
         .serialize()
         .to_vec(),
     )
   }
 }
+
+impl Default for Registration {
+  fn default() -> Self {
+    Self::new()
+  }
+}