pass signer_address in verify presentation as optional param

Cargo.toml

@@ -147,7 +147,7 @@ optional = true
 
 [dependencies.vade-evan-bbs]
 git = "https://github.com/evannetwork/vade-evan-bbs.git"
-branch = "experimental/develop-next"
+branch = "feature/make-signer-address-optional"
 optional = true
 default-features = false
 

VERSIONS.md

@@ -13,6 +13,7 @@
     - `issuer_proving_key`
 - add `helper_convert_credential_to_nquads` helper function
 - add optional param `credential_values` to `helper_create_credential_offer` helper function
+- update `helper_verify_presentation` for optional `signer_address`
 
 ### Fixes
 

src/helpers/presentation.rs

@@ -291,33 +291,42 @@ impl<'a> Presentation<'a> {
                 .map_err(|err| PresentationError::InternalError(err.to_string()))?;
         }
 
+        let mut signer_address = None;
         // extract signing address
-        let mut presentation_value: Value = serde_json::from_str(presentation_str).map_err(
-            PresentationError::to_deserialization_error("presentation", &presentation_str),
-        )?;
-
-        let presentation_value_with_proof =
-            presentation_value.as_object_mut().ok_or_else(|| {
-                PresentationError::InternalError("Error in parsing presentation proof".to_string())
-            })?;
+        if presentation.proof.is_some() {
+            let mut presentation_value: Value = serde_json::from_str(presentation_str).map_err(
+                PresentationError::to_deserialization_error("presentation", &presentation_str),
+            )?;
 
-        let presentation_value_without_proof = presentation_value_with_proof
-            .remove("proof")
-            .ok_or_else(|| {
-                PresentationError::InternalError("Error in parsing presentation proof".to_string())
-            })?;
+            let presentation_value_with_proof =
+                presentation_value.as_object_mut().ok_or_else(|| {
+                    PresentationError::InternalError(
+                        "Error in parsing presentation proof".to_string(),
+                    )
+                })?;
 
-        let (signer_address, _) = recover_address_and_data(
-            presentation_value_without_proof["jws"]
-                .as_str()
+            let presentation_value_without_proof = presentation_value_with_proof
+                .remove("proof")
                 .ok_or_else(|| {
                     PresentationError::InternalError(
                         "Error in parsing presentation proof".to_string(),
                     )
-                })?,
-        )
-        .map_err(|err| PresentationError::InternalError(err.to_string()))?;
-        let signer_address = format!("0x{}", signer_address);
+                })?;
+
+            let (address, _) = recover_address_and_data(
+                presentation_value_without_proof["jws"]
+                    .as_str()
+                    .ok_or_else(|| {
+                        PresentationError::InternalError(
+                            "Error in parsing presentation proof".to_string(),
+                        )
+                    })?,
+            )
+            .map_err(|err| PresentationError::InternalError(err.to_string()))?;
+
+            signer_address = Some(format!("0x{}", address));
+        }
+
         let proof_request = VerifyProofPayload {
             presentation: presentation.clone(),
             proof_request,
@@ -913,7 +922,8 @@ mod tests_proof_request {
     }
 
     #[tokio::test]
-    async fn helper_can_create_presentation_and_reveal_all_if_none_required_revealed() -> Result<()> {
+    async fn helper_can_create_presentation_and_reveal_all_if_none_required_revealed() -> Result<()>
+    {
         let mut vade_evan = VadeEvan::new(crate::VadeEvanConfig {
             target: DEFAULT_TARGET,
             signer: DEFAULT_SIGNER,
@@ -944,12 +954,19 @@ mod tests_proof_request {
             .await;
         assert!(presentation_result.is_ok());
         let presentation: ProofPresentation = serde_json::from_str(&presentation_result?)?;
-        assert_eq!(presentation.verifiable_credential[0].credential_subject.data.len(), 5);
+        assert_eq!(
+            presentation.verifiable_credential[0]
+                .credential_subject
+                .data
+                .len(),
+            5
+        );
         Ok(())
     }
 
     #[tokio::test]
-    async fn helper_can_create_presentation_and_reveal_only_required_attributes_in_credential_subject() -> Result<()> {
+    async fn helper_can_create_presentation_and_reveal_only_required_attributes_in_credential_subject(
+    ) -> Result<()> {
         let mut vade_evan = VadeEvan::new(crate::VadeEvanConfig {
             target: DEFAULT_TARGET,
             signer: DEFAULT_SIGNER,
@@ -981,7 +998,13 @@ mod tests_proof_request {
 
         assert!(presentation_result.is_ok());
         let presentation: ProofPresentation = serde_json::from_str(&presentation_result?)?;
-        assert_eq!(presentation.verifiable_credential[0].credential_subject.data.len(), 1);
+        assert_eq!(
+            presentation.verifiable_credential[0]
+                .credential_subject
+                .data
+                .len(),
+            1
+        );
 
         Ok(())
     }

src/wasm_lib.rs

@@ -196,7 +196,6 @@ struct HelperConvertCredentialToNquads {
     pub credential_str: String,
 }
 
-
 #[wasm_bindgen]
 pub fn set_panic_hook() {
     console_error_panic_hook::set_once();
@@ -814,35 +813,42 @@ pub async fn execute_vade(
         "helper_convert_credential_to_nquads" => {
             let payload_result = parse::<HelperConvertCredentialToNquads>(&payload);
             match payload_result {
-                Ok(payload) => {
-                    helper_convert_credential_to_nquads(payload.credential_str).await
-                }
+                Ok(payload) => helper_convert_credential_to_nquads(payload.credential_str).await,
                 Err(error) => Err(get_parsing_error_message(&error, &payload)),
             }
         }
         #[cfg(all(feature = "vc-zkp-bbs", feature = "did-sidetree"))]
         "helper_create_proof_proposal" => {
             let payload_result = parse::<HelperCreateProofProposalPayload>(&payload);
             match payload_result {
-                Ok(payload) =>
-                    helper_create_proof_proposal(payload.schema_did, payload.revealed_attributes).await,
+                Ok(payload) => {
+                    helper_create_proof_proposal(payload.schema_did, payload.revealed_attributes)
+                        .await
+                }
                 Err(error) => Err(get_parsing_error_message(&error, &payload)),
             }
         }
         #[cfg(all(feature = "vc-zkp-bbs", feature = "did-sidetree"))]
         "helper_create_proof_request" => {
             let payload_result = parse::<HelperCreateProofRequestPayload>(&payload);
             match payload_result {
-                Ok(parsed_value) =>
-                    match parsed_value {
-                        HelperCreateProofRequestPayload::FromScratch(from_scratch) =>
-                            helper_create_proof_request(from_scratch.schema_did, from_scratch.revealed_attributes).await,
-                        HelperCreateProofRequestPayload::FromProposal(proposal) =>
-                            match serde_json::to_string(&proposal) {
-                                Ok(stringified) => helper_create_proof_request_from_proposal(&stringified).await,
-                                Err(error) => Err(get_parsing_error_message(&error, &payload)),
-                            },
-                    },
+                Ok(parsed_value) => match parsed_value {
+                    HelperCreateProofRequestPayload::FromScratch(from_scratch) => {
+                        helper_create_proof_request(
+                            from_scratch.schema_did,
+                            from_scratch.revealed_attributes,
+                        )
+                        .await
+                    }
+                    HelperCreateProofRequestPayload::FromProposal(proposal) => {
+                        match serde_json::to_string(&proposal) {
+                            Ok(stringified) => {
+                                helper_create_proof_request_from_proposal(&stringified).await
+                            }
+                            Err(error) => Err(get_parsing_error_message(&error, &payload)),
+                        }
+                    }
+                },
                 Err(error) => Err(get_parsing_error_message(&error, &payload)),
             }
         }