Merge remote-tracking branch 'origin/develop' into feature/fix-critic…

…al-dependency-updates

.github/workflows/ci_pull_request.yml

@@ -24,7 +24,7 @@ jobs:
           - x86_64-apple-darwin
           - aarch64-apple-darwin
           - x86_64-pc-windows-msvc
-          - x86_64-pc-windows-gnu,
+          - x86_64-pc-windows-gnu
 
         toolchain:
           - stable

Cargo.toml

@@ -97,7 +97,7 @@ optional = true
 # did-substrate
 [dependencies.vade-evan-substrate]
 git = "https://github.com/evannetwork/vade-evan-substrate.git"
-branch = "feature/fix-critical-dependency-updates"
+branch = "develop"
 optional = true
 
 # didcomm
@@ -115,7 +115,7 @@ optional = true
 # signer
 [dependencies.vade-signer]
 git = "https://github.com/evannetwork/vade-signer.git"
-branch = "feature/fix-critical-dependency-updates"
+branch = "develop"
 optional = true
 
 # universal-resolver

VERSIONS.md

@@ -30,6 +30,7 @@
 - refactor features to use target specific(c-lib, c-sdk, wasm, cli, java) builds
 - adjust functions to remove `credential_subject.id` from `BbsCredential` and other types
 - add `helper_verify_presentation`
+- add support for `required_reveal_statements` in `vade-evan-bbs`
 
 ### Fixes
 

src/api/vade_evan_api.rs

@@ -285,6 +285,7 @@ impl VadeEvan {
     /// * `use_valid_until` - true if `validUntil` will be present in credential
     /// * `issuer_did` - DID of issuer
     /// * `is_credential_status_included` - true if credentialStatus is included in credential
+    /// * `required_reveal_statements` - required_revealed_statements indices array in searialized form
     ///
     /// # Returns
     /// * credential offer as JSON serialized [`BbsCredentialOffer`](https://docs.rs/vade_evan_bbs/*/vade_evan_bbs/struct.BbsCredentialOffer.html)
@@ -307,6 +308,7 @@ impl VadeEvan {
     ///                     false,
     ///                     ISSUER_DID,
     ///                     true,
+    ///                     "[1]",
     ///                 )
     ///                 .await?;
     ///
@@ -324,6 +326,7 @@ impl VadeEvan {
         use_valid_until: bool,
         issuer_did: &str,
         is_credential_status_included: bool,
+        required_reveal_statements: &str,
     ) -> Result<String, VadeEvanError> {
         let mut credential = Credential::new(self)?;
         credential
@@ -332,6 +335,7 @@ impl VadeEvan {
                 use_valid_until,
                 issuer_did,
                 is_credential_status_included,
+                required_reveal_statements,
             )
             .await
             .map_err(|err| err.into())
@@ -853,6 +857,7 @@ impl VadeEvan {
     /// * `credential_revocation_did` - revocation list DID
     /// * `credential_revocation_id` - index in revocation list
     /// * `exp_date` - expiration date, string, e.g. "1722-12-03T14:23:42.120Z" (or `None` if no expiration date is used)
+    /// * `required_revealed_statements` - required_revealed_statements indices array in searialized form
     ///
     /// # Returns
     /// * credential as JSON serialized [`BbsCredential`](https://docs.rs/vade_evan_bbs/*/vade_evan_bbs/struct.BbsCredential.html)
@@ -875,6 +880,7 @@ impl VadeEvan {
     ///         const BBS_SECRET: &str = "GRsdzRB0pf/8MKP/ZBOM2BEV1A8DIDfmLh8T3b1hPKc=";
     ///         const BBS_PRIVATE_KEY: &str = "WWTZW8pkz35UnvsUCEsof2CJmNHaJQ/X+B5xjWcHr/I=";
     ///         const SUBJECT_DID: &str = "did:evan:EiAee4ixDnSP0eWyp0YFV7Wt9yrZ3w841FNuv9NSLFSCVA";
+    ///
     ///         async fn example() -> Result<()> {
     ///             let mut vade_evan = VadeEvan::new(VadeEvanConfig { target: DEFAULT_TARGET, signer: DEFAULT_SIGNER })?;
     ///             let offer_str = vade_evan
@@ -886,7 +892,8 @@ impl VadeEvan {
     ///                     Some("did:revoc:12345"),
     ///                     Some("1"),
     ///                     None,
-    ///                     SUBJECT_DID
+    ///                     SUBJECT_DID,
+    ///                     "[1]",
     ///                 )
     ///                 .await?;
     ///
@@ -908,6 +915,7 @@ impl VadeEvan {
         credential_revocation_id: Option<&str>,
         exp_date: Option<&str>,
         subject_did: &str,
+        required_reveal_statements: &str,
     ) -> Result<String, VadeEvanError> {
         let mut credential = Credential::new(self)?;
         credential
@@ -920,6 +928,7 @@ impl VadeEvan {
                 credential_revocation_id,
                 exp_date,
                 subject_did,
+                required_reveal_statements,
             )
             .await
             .map_err(|err| err.into())

src/c_lib.rs

@@ -547,6 +547,7 @@ pub extern "C" fn execute_vade(
                         use_valid_until,
                         arguments_vec.get(2).unwrap_or_else(|| &no_args),
                         is_credential_status_included,
+                        arguments_vec.get(4).unwrap_or_else(|| &no_args),
                     )
                     .await
                     .map_err(stringify_vade_evan_error)
@@ -640,6 +641,7 @@ pub extern "C" fn execute_vade(
                         arguments_vec.get(5).map(|v| v.as_str()),
                         arguments_vec.get(6).map(|v| v.as_str()),
                         arguments_vec.get(7).unwrap_or_else(|| &no_args),
+                        arguments_vec.get(8).unwrap_or_else(|| &no_args),
                     )
                     .await
                     .map_err(stringify_vade_evan_error)

src/helpers/credential.rs

@@ -128,9 +128,11 @@ impl<'a> Credential<'a> {
         use_valid_until: bool,
         issuer_did: &str,
         is_credential_status_included: bool,
+        required_reveal_statements: &str,
     ) -> Result<String, CredentialError> {
         let schema: CredentialSchema = self.get_did_document(schema_did).await?;
-
+        let required_reveal_statements: Vec<u32> = serde_json::from_str(required_reveal_statements)
+            .map_err(|err| CredentialError::JsonDeSerialization(err))?;
         let payload = OfferCredentialPayload {
             draft_credential: schema.to_draft_credential(CredentialDraftOptions {
                 issuer_did: issuer_did.to_string(),
@@ -145,6 +147,7 @@ impl<'a> Credential<'a> {
                 true => LdProofVcDetailOptionsCredentialStatusType::RevocationList2021Status,
                 false => LdProofVcDetailOptionsCredentialStatusType::None,
             },
+            required_reveal_statements,
         };
 
         let result = self
@@ -347,11 +350,14 @@ impl<'a> Credential<'a> {
         credential_revocation_id: Option<&str>,
         exp_date: Option<&str>,
         subject_did: &str,
+        required_reveal_statements: &str,
     ) -> Result<String, CredentialError> {
         let credential_revocation_did = check_for_optional_empty_params(credential_revocation_did);
         let credential_revocation_id = check_for_optional_empty_params(credential_revocation_id);
         let exp_date = check_for_optional_empty_params(exp_date);
         let credential_subject: CredentialSubject = serde_json::from_str(credential_subject_str)?;
+        let required_reveal_statements: Vec<u32> = serde_json::from_str(required_reveal_statements)
+            .map_err(|err| CredentialError::JsonDeSerialization(err))?;
         let issuer_public_key = self
             .get_issuer_public_key(&subject_did, "#bbs-key-1")
             .await?;
@@ -399,6 +405,7 @@ impl<'a> Credential<'a> {
                 true => LdProofVcDetailOptionsCredentialStatusType::RevocationList2021Status,
                 false => LdProofVcDetailOptionsCredentialStatusType::None,
             },
+            required_reveal_statements,
         };
 
         let offer_str = self
@@ -423,15 +430,13 @@ impl<'a> Credential<'a> {
             .await?;
         let (request, blinding_key): (BbsCredentialRequest, String) =
             serde_json::from_str(request_str.as_str())?;
-        let indices = vec![0, 1];
 
         // Issue credentials
         let payload = IssueCredentialPayload {
             issuer_public_key_id: "#bbs-key-1".to_string(),
             issuer_public_key: issuer_public_key.clone(),
             issuer_secret_key: bbs_private_key.to_string(),
             credential_request: request.clone(),
-            required_indices: indices,
             credential_status,
         };
         let payload_str = serde_json::to_string(&payload)?;
@@ -699,10 +704,17 @@ mod tests {
         let mut credential = Credential::new(&mut vade_evan)?;
 
         let offer_str = credential
-            .create_credential_offer(SCHEMA_DID, false, ISSUER_DID, true)
+            .create_credential_offer(SCHEMA_DID, false, ISSUER_DID, true, "[1]")
             .await?;
 
         let offer_obj: BbsCredentialOffer = serde_json::from_str(&offer_str)?;
+        assert_eq!(
+            offer_obj
+                .ld_proof_vc_detail
+                .options
+                .required_reveal_statements,
+            vec![1]
+        );
         assert_eq!(offer_obj.ld_proof_vc_detail.credential.issuer, ISSUER_DID);
         assert!(!offer_obj.nonce.is_empty());
 
@@ -717,7 +729,7 @@ mod tests {
             signer: "remote|http://127.0.0.1:7070/key/sign",
         })?;
         let credential_offer = vade_evan
-            .helper_create_credential_offer(SCHEMA_DID, false, ISSUER_DID, true)
+            .helper_create_credential_offer(SCHEMA_DID, false, ISSUER_DID, true, "[1]")
             .await?;
 
         let bbs_secret = r#"OASkVMA8q6b3qJuabvgaN9K1mKoqptCv4SCNvRmnWuI="#;
@@ -994,10 +1006,15 @@ mod tests {
                 Some("1"),
                 None,
                 subject_id,
+                "[1]",
             )
             .await
         {
-            Ok(_) => assert!(true, "credential should have been successfully self issued"),
+            Ok(issued_credential) => {
+                assert!(true, "credential should have been successfully self issued");
+                let issue_credential: BbsCredential = serde_json::from_str(&issued_credential)?;
+                assert_eq!(issue_credential.proof.required_reveal_statements, vec![1]);
+            }
             Err(_) => assert!(
                 false,
                 "error occured when creating the self issued credential"
@@ -1036,6 +1053,7 @@ mod tests {
                 None,
                 None,
                 subject_id,
+                "[1]",
             )
             .await
         {
@@ -1046,6 +1064,7 @@ mod tests {
                     issue_credential.credential_status.is_none(),
                     "credential_status should not be present"
                 );
+                assert_eq!(issue_credential.proof.required_reveal_statements, vec![1]);
             }
             Err(_) => assert!(
                 false,

src/main.rs

@@ -189,6 +189,7 @@ async fn main() -> Result<()> {
                         use_valid_until,
                         get_argument_value(sub_m, "issuer_did", None),
                         include_credential_status,
+                        get_argument_value(sub_m, "required_reveal_statements", None),
                     )
                     .await?
             }
@@ -260,6 +261,7 @@ async fn main() -> Result<()> {
                         get_optional_argument_value(sub_m, "credential_revocation_id"),
                         get_optional_argument_value(sub_m, "exp_date"),
                         get_argument_value(sub_m, "subject_did", None),
+                        get_argument_value(sub_m, "required_reveal_statements", None),
                     )
                     .await?;
                 "".to_string()
@@ -329,6 +331,7 @@ fn add_subcommand_helper<'a>(app: App<'a, 'a>) -> Result<App<'a, 'a>> {
                     .arg(get_clap_argument("use_valid_until")?)
                     .arg(get_clap_argument("issuer_did")?)
                     .arg(get_clap_argument("include_credential_status")?)
+                    .arg(get_clap_argument("required_reveal_statements")?)
             );
         } else {}
     }
@@ -416,6 +419,7 @@ fn add_subcommand_helper<'a>(app: App<'a, 'a>) -> Result<App<'a, 'a>> {
                     .arg(get_clap_argument("credential_revocation_id")?)
                     .arg(get_clap_argument("exp_date")?)
                     .arg(get_clap_argument("subject_did")?)
+                    .arg(get_clap_argument("required_reveal_statements")?)
             );
         } else {}
     }
@@ -978,6 +982,12 @@ fn get_clap_argument(arg_name: &str) -> Result<Arg> {
             .value_name("revealed_attributes")
             .help("list of names of revealed attributes in specified schema, reveals all if omitted")
             .takes_value(true),
+        "required_reveal_statements" => Arg::with_name("required_reveal_statements")
+            .long("required_reveal_statements")
+            .value_name("required_reveal_statements")
+            .help("list of indices to be made as revealed mandatorily in credential presentation")
+            .takes_value(true)
+            .required(true),
         "proof_request" => Arg::with_name("proof_request")
             .long("proof_request")
             .value_name("proof_request")