fix: rename tokens_verified, tokens_for_auth

Author: samparsky

adapter/src/dummy.rs

@@ -8,8 +8,10 @@ use std::collections::HashMap;
 pub struct DummyAdapter {
     identity: String,
     config: Config,
-    tokens_verified: HashMap<String, String>,
-    tokens_for_auth: HashMap<String, String>,
+    // Auth tokens that we have verified (tokenId => session)
+    session_tokens: HashMap<String, String>,
+    // Auth tokens that we've generated to authenticate with someone (address => token)
+    authorization_tokens: HashMap<String, String>,
 }
 
 // Enables DummyAdapter to be able to
@@ -20,10 +22,10 @@ impl Adapter for DummyAdapter {
     type Output = DummyAdapter;
 
     fn init(opts: AdapterOptions, config: &Config) -> AdapterResult<DummyAdapter> {
-        let (identity, tokens_for_auth, tokens_verified) =
+        let (identity, authorization_tokens, session_tokens) =
             match (opts.dummy_identity, opts.dummy_auth, opts.dummy_auth_tokens) {
-                (Some(identity), Some(tokens_for_auth), Some(tokens_verified)) => {
-                    (identity, tokens_for_auth, tokens_verified)
+                (Some(identity), Some(authorization_tokens), Some(session_tokens)) => {
+                    (identity, authorization_tokens, session_tokens)
                 }
                 (_, _, _) => {
                     return Err(AdapterError::Configuration(
@@ -35,8 +37,8 @@ impl Adapter for DummyAdapter {
         Ok(Self {
             identity,
             config: config.to_owned(),
-            tokens_verified,
-            tokens_for_auth,
+            session_tokens,
+            authorization_tokens,
         })
     }
 
@@ -77,7 +79,7 @@ impl Adapter for DummyAdapter {
 
     fn session_from_token(&self, token: &str) -> AdapterResult<Session> {
         let identity = self
-            .tokens_for_auth
+            .authorization_tokens
             .clone()
             .into_iter()
             .find(|(_, id)| *id == token);
@@ -93,14 +95,14 @@ impl Adapter for DummyAdapter {
 
     fn get_auth(&self, _validator: &ValidatorDesc) -> AdapterResult<String> {
         let who = self
-            .tokens_verified
+            .session_tokens
             .clone()
             .into_iter()
             .find(|(_, id)| *id == self.identity);
 
         match who {
             Some((id, _)) => {
-                let auth = self.tokens_for_auth.get(&id).expect("id should exist");
+                let auth = self.authorization_tokens.get(&id).expect("id should exist");
                 Ok(auth.to_owned())
             }
             None => Err(AdapterError::Authentication(format!(

adapter/src/ethereum.rs

@@ -34,8 +34,10 @@ pub struct EthereumAdapter {
     keystore_json: String,
     keystore_pwd: Password,
     config: Config,
-    tokens_verified: RefCell<HashMap<String, Session>>,
-    tokens_for_auth: RefCell<HashMap<String, String>>,
+    // Auth tokens that we have verified (tokenId => session)
+    session_tokens: RefCell<HashMap<String, Session>>,
+    // Auth tokens that we've generated to authenticate with someone (address => token)
+    authorization_tokens: RefCell<HashMap<String, String>>,
     wallet: RefCell<Option<SafeAccount>>,
 }
 
@@ -59,8 +61,8 @@ impl Adapter for EthereumAdapter {
         Ok(Self {
             keystore_json,
             keystore_pwd: keystore_pwd.into(),
-            tokens_verified: RefCell::new(HashMap::new()),
-            tokens_for_auth: RefCell::new(HashMap::new()),
+            session_tokens: RefCell::new(HashMap::new()),
+            authorization_tokens: RefCell::new(HashMap::new()),
             wallet: RefCell::new(None),
             config: config.to_owned(),
         })
@@ -87,10 +89,10 @@ impl Adapter for EthereumAdapter {
     fn whoami(&self) -> AdapterResult<String> {
         match self.wallet.borrow().clone() {
             Some(wallet) => {
-                let public = &wallet
+                let public = wallet
                     .public(&self.keystore_pwd)
                     .map_err(|_| map_error("Failed to get public key"))?;
-                let address = format!("{:?}", public_to_address(public));
+                let address = format!("{:?}", public_to_address(&public));
                 let checksum_address = eth_checksum::checksum(&address);
                 Ok(checksum_address)
             }
@@ -173,7 +175,7 @@ impl Adapter for EthereumAdapter {
         let is_channel_valid = EthereumAdapter::is_channel_valid(&self.config, channel);
         if is_channel_valid.is_err() {
             return Err(AdapterError::InvalidChannel(
-                is_channel_valid.err().unwrap().to_string(),
+                is_channel_valid.err().expect("failed to get channel error").to_string(),
             ));
         }
 
@@ -194,9 +196,9 @@ impl Adapter for EthereumAdapter {
 
     fn session_from_token(&self, token: &str) -> AdapterResult<Session> {
         let token_id = token.to_owned()[..16].to_string();
-        let result = self.tokens_verified.borrow_mut();
+        let result = self.session_tokens.borrow_mut();
         if result.get(&token_id).is_some() {
-            return Ok(result.get(&token_id).unwrap().to_owned());
+            return Ok(result.get(&token_id).expect("failed to get session").to_owned());
         }
 
         let verified = match ewt_verify(&token) {
@@ -246,17 +248,17 @@ impl Adapter for EthereumAdapter {
             },
         };
 
-        self.tokens_verified
+        self.session_tokens
             .borrow_mut()
             .insert(token_id, sess.clone());
         Ok(sess)
     }
 
     fn get_auth(&self, validator: &ValidatorDesc) -> AdapterResult<String> {
-        let tokens_for_auth = self.tokens_for_auth.borrow();
+        let authorization_tokens = self.authorization_tokens.borrow();
         match (
             self.wallet.borrow().clone(),
-            tokens_for_auth.get(&validator.id),
+            authorization_tokens.get(&validator.id),
         ) {
             (Some(_), Some(token)) => Ok(token.to_owned()),
             (Some(wallet), None) => {
@@ -269,7 +271,7 @@ impl Adapter for EthereumAdapter {
                 let token = ewt_sign(&wallet, &self.keystore_pwd, &payload)
                     .map_err(|_| map_error("Failed to sign token"))?;
 
-                self.tokens_for_auth
+                self.authorization_tokens
                     .borrow_mut()
                     .insert(validator.id.clone(), token.clone());