Created new version of AuthToken that can be converted to and from String

sfw-provider/sfw-provider-requests/Cargo.toml

@@ -7,4 +7,5 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+bs58 = "0.3.0"
 sphinx = { git = "https://github.com/nymtech/sphinx", rev="8424f4b0933b4a7f64ae828b2edefc5ba43a9e79" }

sfw-provider/sfw-provider-requests/src/lib.rs

@@ -5,3 +5,96 @@ pub const DUMMY_MESSAGE_CONTENT: &[u8] =
     b"[DUMMY MESSAGE] Wanting something does not give you the right to have it.";
 
 pub type AuthToken = [u8; 32];
+
+// To be renamed to 'AuthToken' once it is safe to replace it
+#[derive(Debug, PartialEq)]
+pub struct AuthToken2(pub [u8; 32]);
+
+#[derive(Debug)]
+pub enum AuthTokenConversionError {
+    InvalidStringError,
+    StringOfInvalidLengthError,
+}
+
+impl AuthToken2 {
+    pub fn try_from_base58_string<S: Into<String>>(
+        val: S,
+    ) -> Result<Self, AuthTokenConversionError> {
+        let decoded = match bs58::decode(val.into()).into_vec() {
+            Ok(decoded) => decoded,
+            Err(_) => return Err(AuthTokenConversionError::InvalidStringError),
+        };
+
+        if decoded.len() != 32 {
+            return Err(AuthTokenConversionError::StringOfInvalidLengthError);
+        }
+
+        let mut token = [0u8; 32];
+        token.copy_from_slice(&decoded[..]);
+        Ok(AuthToken2(token))
+    }
+
+    pub fn to_base58_string(&self) -> String {
+        bs58::encode(self.0).into_string()
+    }
+}
+
+#[cfg(test)]
+mod auth_token_conversion {
+    use super::*;
+
+    #[test]
+    fn it_is_possible_to_recover_it_from_valid_b58_string() {
+        let auth_token = AuthToken2([42; 32]);
+        let auth_token_string = auth_token.to_base58_string();
+        assert_eq!(
+            auth_token,
+            AuthToken2::try_from_base58_string(auth_token_string).unwrap()
+        )
+    }
+
+    #[test]
+    fn it_is_possible_to_recover_it_from_valid_b58_str_ref() {
+        let auth_token = AuthToken2([42; 32]);
+        let auth_token_string = auth_token.to_base58_string();
+        let auth_token_str_ref: &str = &auth_token_string;
+        assert_eq!(
+            auth_token,
+            AuthToken2::try_from_base58_string(auth_token_str_ref).unwrap()
+        )
+    }
+
+    #[test]
+    fn it_returns_error_on_b58_with_invalid_characters() {
+        let auth_token = AuthToken2([42; 32]);
+        let auth_token_string = auth_token.to_base58_string();
+
+        let mut chars = auth_token_string.chars();
+        let _consumed_first_char = chars.next().unwrap();
+
+        let invalid_chars_token = "=".to_string() + chars.as_str();
+        assert!(AuthToken2::try_from_base58_string(invalid_chars_token).is_err())
+    }
+
+    #[test]
+    fn it_returns_error_on_too_long_b58_string() {
+        let auth_token = AuthToken2([42; 32]);
+        let mut auth_token_string = auth_token.to_base58_string();
+        auth_token_string.push('f');
+
+        assert!(AuthToken2::try_from_base58_string(auth_token_string).is_err())
+    }
+
+    #[test]
+    fn it_returns_error_on_too_short_b58_string() {
+        let auth_token = AuthToken2([42; 32]);
+        let auth_token_string = auth_token.to_base58_string();
+
+        let mut chars = auth_token_string.chars();
+        let _consumed_first_char = chars.next().unwrap();
+        let _consumed_second_char = chars.next().unwrap();
+        let invalid_chars_token = chars.as_str();
+
+        assert!(AuthToken2::try_from_base58_string(invalid_chars_token).is_err())
+    }
+}