Make code more rust idiomatic

src/holder.rs

@@ -152,20 +152,10 @@ impl SDJWTHolder {
             .unwrap_or(&default_list)
             .iter()
             .filter_map(|digest| {
-                let digest = match digest.as_str() {
-                    Some(digest) => digest,
-                    None => return None,
-                };
-                if let Some(Value::Array(disclosure)) =
-                    self.sd_jwt_engine.hash_to_decoded_disclosure.get(digest)
-                {
-                    let key = match disclosure[1].as_str() {
-                        Some(digest) => digest,
-                        None => return None,
-                    };
-                    return Some((key, (&disclosure[2], digest)));
-                }
-                None
+                let digest = digest.as_str()?;
+                let disclosure = self.sd_jwt_engine.hash_to_decoded_disclosure.get(digest)?;
+                let key = disclosure[1].as_str()?;
+                Some((key, (&disclosure[2], digest)))
             })
             .collect(); //TODO split to 2 maps
         for (key_to_disclose, value_to_disclose) in claims_to_disclose {
@@ -323,7 +313,7 @@ impl SDJWTHolder {
         self.set_key_binding_digest_key()?;
         // Create key-binding jwt
         let mut header = Header::new(
-            Algorithm::from_str(alg.as_str())
+            Algorithm::from_str(&alg)
                 .map_err(|e| Error::DeserializationError(e.to_string()))?,
         );
         header.typ = Some(crate::KB_JWT_TYP_HEADER.into());

src/issuer.rs

@@ -317,46 +317,45 @@ impl SDJWTIssuer {
     }
 
     fn create_combined(&mut self) -> Result<()> {
-        if self.inner.serialization_format == SDJWTSerializationFormat::Compact {
-            let mut disclosures: VecDeque<String> = self
-                .all_disclosures
-                .iter()
-                .map(|d| d.raw_b64.to_string())
-                .collect();
-            disclosures.push_front(self.signed_sd_jwt.clone());
-
-            let disclosures: Vec<&str> = disclosures.iter().map(|s| s.as_str()).collect();
-
-            self.serialized_sd_jwt = format!(
-                "{}{}",
-                disclosures.join(COMBINED_SERIALIZATION_FORMAT_SEPARATOR),
-                COMBINED_SERIALIZATION_FORMAT_SEPARATOR,
-            );
-        } else if self.inner.serialization_format == SDJWTSerializationFormat::JSON {
-            let jwt: Vec<&str> = self.signed_sd_jwt.split('.').collect();
-            if jwt.len() != 3 {
-                return Err(Error::InvalidInput(format!(
-                    "Invalid JWT, JWT must contain three parts after splitting with \".\": jwt {}",
-                    self.signed_sd_jwt
-                )));
-            }
-            let sd_jwt_json = SDJWTJson {
-                protected: jwt[0].to_owned(),
-                payload: jwt[1].to_owned(),
-                signature: jwt[2].to_owned(),
-                kb_jwt: None,
-                disclosures: self
+        match self.inner.serialization_format  {
+            SDJWTSerializationFormat::Compact => {
+                let mut disclosures: VecDeque<String> = self
                     .all_disclosures
                     .iter()
                     .map(|d| d.raw_b64.to_string())
-                    .collect(),
-            };
-            self.serialized_sd_jwt = serde_json::to_string(&sd_jwt_json)
-                .map_err(|e| Error::DeserializationError(e.to_string()))?;
-        } else {
-            return Err(Error::InvalidInput(
-                format!("Unknown serialization format {}, only \"Compact\" or \"JSON\" formats are supported", self.inner.serialization_format)
-            ));
+                    .collect();
+                disclosures.push_front(self.signed_sd_jwt.clone());
+
+                let disclosures: Vec<&str> = disclosures.iter().map(|s| s.as_str()).collect();
+
+                self.serialized_sd_jwt = format!(
+                    "{}{}",
+                    disclosures.join(COMBINED_SERIALIZATION_FORMAT_SEPARATOR),
+                    COMBINED_SERIALIZATION_FORMAT_SEPARATOR,
+                );
+            },
+            SDJWTSerializationFormat::JSON => {
+                let jwt: Vec<&str> = self.signed_sd_jwt.split('.').collect();
+                if jwt.len() != 3 {
+                    return Err(Error::InvalidInput(format!(
+                        "Invalid JWT, JWT must contain three parts after splitting with \".\": jwt {}",
+                        self.signed_sd_jwt
+                    )));
+                }
+                let sd_jwt_json = SDJWTJson {
+                    protected: jwt[0].to_owned(),
+                    payload: jwt[1].to_owned(),
+                    signature: jwt[2].to_owned(),
+                    kb_jwt: None,
+                    disclosures: self
+                        .all_disclosures
+                        .iter()
+                        .map(|d| d.raw_b64.to_string())
+                        .collect(),
+                };
+                self.serialized_sd_jwt = serde_json::to_string(&sd_jwt_json)
+                    .map_err(|e| Error::DeserializationError(e.to_string()))?;
+            }
         }
 
         Ok(())

src/lib.rs

@@ -33,6 +33,7 @@ const CNF_KEY: &str = "cnf";
 const JWK_KEY: &str = "jwk";
 
 #[derive(Debug)]
+#[allow(dead_code)]
 pub(crate) struct SDJWTHasSDClaimException(String);
 
 impl SDJWTHasSDClaimException {}
@@ -146,7 +147,7 @@ impl SDJWTCommon {
             length: parts.len(),
             msg: format!("Invalid SD-JWT: {}", sd_jwt_with_disclosures),
         })?;
-        self.sign_alg = Self::decode_header_and_get_sign_algorithm(&sd_jwt);
+        self.sign_alg = Self::decode_header_and_get_sign_algorithm(sd_jwt);
         self.unverified_input_key_binding_jwt = Some(
             parts
                 .next_back()

src/verifier.rs

@@ -76,7 +76,7 @@ impl SDJWTVerifier {
             let sign_alg = verifier.sd_jwt_engine.unverified_input_key_binding_jwt
                 .as_ref()
                 .and_then(|value| {
-                    SDJWTCommon::decode_header_and_get_sign_algorithm(&value)
+                    SDJWTCommon::decode_header_and_get_sign_algorithm(value)
                 });
 
             verifier.verify_key_binding_jwt(
@@ -180,10 +180,10 @@ impl SDJWTVerifier {
                     Algorithm::from_str(sign_alg)
                         .map_err(|e| Error::DeserializationError(e.to_string()))?,
                 );
-                validation.set_audience(&[expected_aud.as_str()]);
+                validation.set_audience(&[&expected_aud]);
                 validation.set_required_spec_claims(&["aud"]);
 
-                jsonwebtoken::decode::<Map<String, Value>>(payload.as_str(), &pubkey, &validation)
+                jsonwebtoken::decode::<Map<String, Value>>(&payload, &pubkey, &validation)
                     .map_err(|e| Error::DeserializationError(e.to_string()))?
             }
             None => {
@@ -216,7 +216,6 @@ impl SDJWTVerifier {
                 .unverified_sd_jwt
                 .as_ref()
                 .ok_or(Error::ConversionError("reference".to_string()))?
-                .as_str(),
         );
         combined.extend(
             self.sd_jwt_engine