Expose Presentation methods in uniffi

uniffi/src/anoncreds.udl

@@ -24,6 +24,8 @@ enum AnoncredsError {
   "CreateCredentialOffer",
   "CreateCredential",
   "ProcessCredential",
+  "CreatePresentationError",
+  "ProcessCredentialError",
 };
 
 enum SignatureType {
@@ -296,15 +298,65 @@ interface Prover {
   );
 
   [Throws=AnoncredsError]
-   void process_credential(
-        Credential credential,
-        CredentialRequestMetadata cred_request_metadata,
-        LinkSecret link_secret,
-        CredentialDefinition cred_def,
-        RevocationRegistryDefinition? rev_reg_def
-   );
+  void process_credential(
+    Credential credential,
+    CredentialRequestMetadata cred_request_metadata,
+    LinkSecret link_secret,
+    CredentialDefinition cred_def,
+    RevocationRegistryDefinition? rev_reg_def
+  );
+
+  [Throws=AnoncredsError]
+  Presentation create_presentation(
+    PresentationRequest presentation_request,
+    sequence<CredentialRequests> credentials,
+    record<string, string>? self_attested,
+    LinkSecret link_secret,
+    record<SchemaId, Schema> schemas,
+    record<CredentialDefinitionId, CredentialDefinition> credential_definitions
+  );
 
   LinkSecret create_link_secret();
 };
 
+dictionary RequestedAttribute {
+    string referent;
+    boolean revealed;
+};
+dictionary RequestedPredicate {
+    string referent;
+};
+dictionary CredentialRequests {
+    Credential credential;
+    sequence<RequestedAttribute> requested_attribute;
+    sequence<RequestedPredicate> requested_predicate;
+};
+
+interface Presentation {
+  [Throws=AnoncredsError]
+  constructor(string json_string);
+  [Throws=AnoncredsError]
+  string get_json();
+};
+
+interface PresentationRequest {
+  [Throws=AnoncredsError]
+  constructor(string json_string);
+  [Throws=AnoncredsError]
+  string get_json();
+};
+
+interface Verifier {
+  constructor();
+
+  [Throws=AnoncredsError]
+  boolean verify_presentation(
+    Presentation presentation,
+    PresentationRequest presentation_request,
+    record<SchemaId, Schema> schemas,
+    record<CredentialDefinitionId, CredentialDefinition> credential_definitions
+  );
+
+};
+
 namespace anoncreds {};

uniffi/src/issuer/mod.rs

@@ -1,7 +1,7 @@
 use crate::types::error::AnoncredsError;
 use crate::types::cred_def::{CredentialDefinition, CredentialDefinitionPrivate, CredentialKeyCorrectnessProof};
-use crate::types::cred_offer::{CredentialOffer};
-use crate::types::credential::{Credential};
+use crate::types::cred_offer::CredentialOffer;
+use crate::types::credential::Credential;
 use crate::CredentialRequest;
 use crate::types::rev_status_list::RevocationStatusList;
 use crate::types::rev_reg_def::{RevocationRegistryDefinition, RevocationRegistryDefinitionPrivate};

uniffi/src/lib.rs

@@ -1,33 +1,41 @@
 mod types;
 // mod issuer;
-mod prover;
 mod issuer;
+mod prover;
+mod verifier;
 
-pub use anoncreds_core::data_types::cred_def::CredentialDefinitionId;
-pub use anoncreds_core::data_types::issuer_id::IssuerId;
-pub use anoncreds_core::data_types::rev_reg::RevocationRegistryId;
-pub use anoncreds_core::data_types::rev_reg_def::RevocationRegistryDefinitionId;
-pub use anoncreds_core::data_types::schema::{Schema, SchemaId};
-pub use anoncreds_core::types::{AttributeNames, CredentialDefinitionConfig, SignatureType, RegistryType};
-pub use crate::types::cred_def::{CredentialDefinition, CredentialDefinitionData, CredentialKeyCorrectnessProof};
-pub use crate::types::link_secret::LinkSecret;
-pub use crate::types::nonce::Nonce;
-pub use crate::types::error::AnoncredsError;
+pub use crate::cred_def::CredentialDefinitionPrivate;
+pub use crate::custom_types::{AttributeValues, CredentialValues};
+pub use crate::types::cred_def::{
+    CredentialDefinition, CredentialDefinitionData, CredentialKeyCorrectnessProof,
+};
 pub use crate::types::cred_offer::CredentialOffer;
 pub use crate::types::cred_req::{CredentialRequest, CredentialRequestMetadata};
 pub use crate::types::credential::Credential;
-pub use crate::types::rev_reg_def::RevocationRegistryDefinitionPrivate;
+pub use crate::types::error::AnoncredsError;
+pub use crate::types::link_secret::LinkSecret;
+pub use crate::types::nonce::Nonce;
+pub use crate::types::presentation::Presentation;
+pub use crate::types::presentation::PresentationRequest;
 pub use crate::types::rev_reg_def::RevocationRegistryDefinition;
-pub use crate::types::rev_reg_def::RevocationRegistryDefinitionValuePublicKeys;
+pub use crate::types::rev_reg_def::RevocationRegistryDefinitionPrivate;
 pub use crate::types::rev_reg_def::RevocationRegistryDefinitionValue;
+pub use crate::types::rev_reg_def::RevocationRegistryDefinitionValuePublicKeys;
 pub use crate::types::rev_status_list::RevocationStatusList;
-pub use crate::cred_def::CredentialDefinitionPrivate;
-pub use crate::custom_types::{AttributeValues, CredentialValues};
+pub use anoncreds_core::data_types::cred_def::CredentialDefinitionId;
+pub use anoncreds_core::data_types::issuer_id::IssuerId;
+pub use anoncreds_core::data_types::rev_reg::RevocationRegistryId;
+pub use anoncreds_core::data_types::rev_reg_def::RevocationRegistryDefinitionId;
+pub use anoncreds_core::data_types::schema::{Schema, SchemaId};
+pub use anoncreds_core::types::{
+    AttributeNames, CredentialDefinitionConfig, RegistryType, SignatureType,
+};
 
-pub use types::*;
 pub use issuer::CredentialRevocationConfig;
-pub use prover::*;
 pub use issuer::*;
+pub use prover::*;
+pub use types::*;
+pub use verifier::*;
 
 // fn x() -> AttributeValues
 

uniffi/src/prover/mod.rs

@@ -1,23 +1,37 @@
-use crate::types::link_secret::LinkSecret;
 use crate::error::AnoncredsError;
-use crate::nonce::Nonce;
+use crate::types::cred_def::CredentialDefinition;
 use crate::types::cred_offer::CredentialOffer;
 use crate::types::cred_req::{CredentialRequest, CredentialRequestMetadata};
-use crate::types::cred_def::{CredentialDefinition, CredentialDefinitionData};
-use crate::Credential;
+use crate::types::link_secret::LinkSecret;
+use crate::PresentationRequest;
 use crate::RevocationRegistryDefinition;
-use anoncreds_core::prover::*;
-use anoncreds_core::data_types::cred_request::{CredentialRequest as AnoncredsCredentialRequest, CredentialRequestMetadata as AnoncredsCredentialRequestMetadata};
-use anoncreds_core::types::Credential as AnoncredsCredential;
-use super::types::*;
-use std::sync::Arc;
+use crate::{Credential, Presentation};
+use anoncreds_core::data_types::cred_def::CredentialDefinitionId;
+use anoncreds_core::data_types::schema::{Schema, SchemaId};
+use anoncreds_core::prover;
+use anoncreds_core::types::PresentCredentials as AnoncredsPresentCredentials;
+use std::collections::HashMap;
 use std::convert::TryInto;
+use std::sync::Arc;
 
 pub struct CreateCrendentialRequestResponse {
     pub request: Arc<CredentialRequest>,
     pub metadata: CredentialRequestMetadata,
 }
 
+pub struct RequestedAttribute {
+    pub referent: String,
+    pub revealed: bool,
+}
+pub struct RequestedPredicate {
+    pub referent: String,
+}
+pub struct CredentialRequests {
+    pub credential: Arc<Credential>,
+    pub requested_attribute: Vec<RequestedAttribute>,
+    pub requested_predicate: Vec<RequestedPredicate>,
+}
+
 pub struct Prover {}
 
 impl Prover {
@@ -42,24 +56,23 @@ impl Prover {
         let cred_def_clone = Arc::clone(&cred_def);
         let cred_def_inner = cred_def_clone.as_ref();
         let cred_def_core = cred_def_inner.clone().try_into()?;
-        let link_secret_core =(*link_secret).clone().secret;
+        let link_secret_core = (*link_secret).clone().secret;
         let cred_offer_core = (*credential_offer).clone().core;
-        
+
         let (request, metadata) = anoncreds_core::prover::create_credential_request(
             entropy.as_ref().map(|s| s.as_str()),
             prover_did.as_ref().map(|s| s.as_str()),
             &cred_def_core,
             &link_secret_core,
             link_secret_id.as_str(),
-            &cred_offer_core
-        ).map_err(|err| {
-            AnoncredsError::CreateCrentialRequestError(format!("Error: {}", err))
-        })?;
+            &cred_offer_core,
+        )
+        .map_err(|err| AnoncredsError::CreateCrentialRequestError(format!("Error: {}", err)))?;
 
         return Ok(CreateCrendentialRequestResponse {
             request: Arc::new(CredentialRequest { core: request }),
-            metadata: CredentialRequestMetadata::from(metadata)
-        })
+            metadata: CredentialRequestMetadata::from(metadata),
+        });
     }
 
     pub fn process_credential(
@@ -70,15 +83,66 @@ impl Prover {
         cred_def: Arc<CredentialDefinition>,
         rev_reg_def: Option<Arc<RevocationRegistryDefinition>>,
     ) -> Result<(), AnoncredsError> {
-        let mut mutable_credential = (*credential).core.try_clone().map_err(|_| AnoncredsError::ConversionError)?;
-        process_credential(
+        let mut mutable_credential = (*credential)
+            .core
+            .try_clone()
+            .map_err(|_| AnoncredsError::ConversionError)?;
+        prover::process_credential(
             &mut mutable_credential,
             &cred_request_metadata.into(),
             &(*link_secret).secret,
             &(*cred_def).core,
-            rev_reg_def.as_ref().map(|def| &(*def).core)
-        ).map_err(|err| {
-            AnoncredsError::ProcessCredential(format!("Error: {}", err))
-        })
+            rev_reg_def.as_ref().map(|def| &(*def).core),
+        )
+        .map_err(|err| AnoncredsError::ProcessCredential(format!("Error: {}", err)))
+    }
+
+    pub fn create_presentation(
+        &self,
+        presentation_request: Arc<PresentationRequest>,
+        credentials: Vec<CredentialRequests>,
+        self_attested: Option<HashMap<String, String>>,
+        link_secret: Arc<LinkSecret>,
+        schemas: HashMap<SchemaId, Schema>,
+        credential_definitions: HashMap<CredentialDefinitionId, Arc<CredentialDefinition>>,
+    ) -> Result<Arc<Presentation>, AnoncredsError> {
+        let pres_req = &presentation_request.core;
+
+        let mut present_credentials = AnoncredsPresentCredentials::default();
+        let timestamp = None; // TODO
+        let rev_state = None; //TODO
+
+        credentials.iter().for_each(|c| {
+            let cred = &c.credential.core;
+            let mut tmp = present_credentials.add_credential(cred, timestamp, rev_state);
+
+            c.requested_attribute.iter().for_each(|attribute| {
+                tmp.add_requested_attribute(attribute.referent.to_string(), attribute.revealed);
+            });
+
+            c.requested_predicate.iter().for_each(|predicate| {
+                tmp.add_requested_predicate(predicate.referent.to_string());
+            });
+        });
+
+        let schemas_anoncreds = schemas.iter().map(|(k, v)| (k, v)).collect();
+        let cred_defs = credential_definitions
+            .iter()
+            .map(|(k, v)| {
+                let tmp = &v.core;
+                (k, tmp)
+            })
+            .collect();
+
+        return prover::create_presentation(
+            pres_req,
+            present_credentials,
+            self_attested,
+            &link_secret.secret,
+            &schemas_anoncreds,
+            &cred_defs,
+        )
+        .map_err(|err| AnoncredsError::CreatePresentationError(format!("Error: {}", err)))
+        .map(|e| Arc::new(Presentation { core: e }));
     }
-}
+}

uniffi/src/types/cred_def.rs

@@ -10,9 +10,6 @@ use anoncreds_core::data_types::cred_def::{
 };
 use std::convert::TryFrom;
 use std::convert::TryInto;
-use serde::{Deserialize, Serialize};
-use serde_json::Result as SerdeResult;
-use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct CredentialDefinitionData {

uniffi/src/types/cred_offer.rs

@@ -1,24 +1,18 @@
 use crate::types::error::AnoncredsError;
 use crate::types::nonce::Nonce;
 use anoncreds_core::data_types::schema::SchemaId;
-use anoncreds_core::data_types::cred_def::{
-    CredentialDefinitionId,
-    SignatureType
-};
-use anoncreds_core::data_types::cred_offer::{CredentialOffer as AnoncredsCredentialOffer};
+use anoncreds_core::data_types::cred_def::CredentialDefinitionId;
+use anoncreds_core::data_types::cred_offer::CredentialOffer as AnoncredsCredentialOffer;
 use std::convert::TryFrom;
-use std::convert::TryInto;
-use serde::{Deserialize, Serialize};
-use serde_json::Result as SerdeResult;
 use std::sync::Arc;
 
 pub struct CredentialOffer {
     pub core: AnoncredsCredentialOffer,
 }
 
 impl CredentialOffer {
-    pub fn new(jsonString: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredentialOffer = serde_json::from_str(&jsonString).map_err(|_| AnoncredsError::ConversionError)?;
+    pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
+        let core_def: AnoncredsCredentialOffer = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
         return Ok(CredentialOffer { core: core_def })
     }
 

uniffi/src/types/cred_req.rs

@@ -1,20 +1,16 @@
 use crate::types::error::AnoncredsError;
 use crate::types::nonce::Nonce;
 use anoncreds_core::data_types::cred_request::{CredentialRequest as AnoncredsCredentialRequest, CredentialRequestMetadata as AnoncredsCredentialRequestMetadata};
-use std::convert::TryFrom;
-use std::convert::TryInto;
-use serde::{Deserialize, Serialize};
-use serde_json::Result as SerdeResult;
 use std::sync::Arc;
 
 pub struct CredentialRequest {
     pub core: AnoncredsCredentialRequest
 }
 
 impl CredentialRequest {
-    pub fn new(jsonString: String) -> Result<Self, AnoncredsError> {
+    pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
         let core_def: AnoncredsCredentialRequest =
-            serde_json::from_str(&jsonString).map_err(|_| AnoncredsError::ConversionError)?;
+            serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
         return Ok(CredentialRequest { core: core_def });
     }
 
@@ -42,9 +38,9 @@ pub struct CredentialRequestMetadata {
 }
 
 // impl CredentialRequestMetadata {
-//     pub fn new(jsonString: String) -> Result<Self, AnoncredsError> {
+//     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
 //         let core_def: AnoncredsCredentialRequest =
-//             serde_json::from_str(&jsonString).map_err(|_| AnoncredsError::ConversionError)?;
+//             serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
 //         return Ok(CredentialRequestMetadata { core: core_def });
 //     }