feat: Improve ConversionError

input-output-hk · Dec 18, 2023 · 0aeefdd · 0aeefdd
1 parent 467e4d0
commit 0aeefdd
Show file tree

Hide file tree

Showing 12 changed files with 58 additions and 57 deletions.
diff --git a/.gitignore b/.gitignore
@@ -21,3 +21,4 @@ local.properties
 anoncred-kmm/anoncred-wrapper-rust/src/*
 **/.DS_Store
 anoncred-kmm/anoncred-kmm/anoncred-wrapper-rust/src/*
+uniffi/output-frameworks/anoncreds-jvm/bin/main/anoncreds.kt
diff --git a/uniffi/src/prover/mod.rs b/uniffi/src/prover/mod.rs
@@ -86,7 +86,7 @@ impl Prover {
         let mut mutable_credential = (*credential)
             .core
             .try_clone()
-            .map_err(|_| AnoncredsError::ConversionError)?;
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         prover::process_credential(
             &mut mutable_credential,
             &cred_request_metadata.into(),

diff --git a/uniffi/src/types/cred_def.rs b/uniffi/src/types/cred_def.rs
@@ -21,10 +21,10 @@ impl TryFrom<AnoncredsCredentialDefinitionData> for CredentialDefinitionData {
     type Error = AnoncredsError;
 
     fn try_from(acr: AnoncredsCredentialDefinitionData) -> Result<Self, Self::Error> {
-        let primary = serde_json::to_string(&acr.primary).map_err(|_| AnoncredsError::ConversionError)?;
+        let primary = serde_json::to_string(&acr.primary).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
 
         let revocation = if let Some(rev_key) = &acr.revocation {
-            Some(serde_json::to_string(rev_key).map_err(|_| AnoncredsError::ConversionError)?)
+            Some(serde_json::to_string(rev_key).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?)
         } else {
             None
         };
@@ -41,11 +41,11 @@ impl TryInto<AnoncredsCredentialDefinitionData> for CredentialDefinitionData {
 
     fn try_into(self) -> Result<AnoncredsCredentialDefinitionData, Self::Error> {
         let primary: ursa::cl::CredentialPrimaryPublicKey = serde_json::from_str(&self.primary)
-            .map_err(|_| AnoncredsError::ConversionError)?;
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
 
         let revocation = match &self.revocation {
             Some(rev_key_str) => Some(serde_json::from_str(rev_key_str)
-                .map_err(|_| AnoncredsError::ConversionError)?),
+                .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?),
             None => None,
         };
 
@@ -62,7 +62,7 @@ pub struct CredentialDefinition {
 
 impl CredentialDefinition {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredentialDefinition = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsCredentialDefinition = serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(CredentialDefinition { core: core_def })
     }
 
@@ -83,7 +83,7 @@ impl CredentialDefinition {
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -95,8 +95,8 @@ impl TryInto<AnoncredsCredentialDefinition> for CredentialDefinition {
         let cloned_signature_type = self.core.signature_type.clone();
         let cloned_get_tag = self.core.tag.clone();
         let cloned_issuer_id = self.core.issuer_id.clone();
-        let json_value = serde_json::to_string(&self.core.value).map_err(|_| AnoncredsError::ConversionError)?;
-        let cloned_value = serde_json::from_str(&json_value).map_err(|_| AnoncredsError::ConversionError)?;
+        let json_value = serde_json::to_string(&self.core.value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
+        let cloned_value = serde_json::from_str(&json_value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
 
         let cloned_def = AnoncredsCredentialDefinition {
             schema_id: cloned_schema_id,
@@ -117,8 +117,8 @@ impl TryFrom<AnoncredsCredentialDefinition> for CredentialDefinition {
         let cloned_signature_type = acr.signature_type.clone();
         let cloned_get_tag = acr.tag.clone();
         let cloned_issuer_id = acr.issuer_id.clone();
-        let json_value = serde_json::to_string(&acr.value).map_err(|_| AnoncredsError::ConversionError)?;
-        let cloned_value = serde_json::from_str(&json_value).map_err(|_| AnoncredsError::ConversionError)?;
+        let json_value = serde_json::to_string(&acr.value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
+        let cloned_value = serde_json::from_str(&json_value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
 
         let cloned_def = AnoncredsCredentialDefinition {
             schema_id: cloned_schema_id,
@@ -139,8 +139,8 @@ impl TryFrom<&CredentialDefinition> for AnoncredsCredentialDefinition {
         let cloned_signature_type = def.core.signature_type.clone();
         let cloned_get_tag = def.core.tag.clone();
         let cloned_issuer_id = def.core.issuer_id.clone();
-        let json_value = serde_json::to_string(&def.core.value).map_err(|_| AnoncredsError::ConversionError)?;
-        let cloned_value = serde_json::from_str(&json_value).map_err(|_| AnoncredsError::ConversionError)?;
+        let json_value = serde_json::to_string(&def.core.value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
+        let cloned_value = serde_json::from_str(&json_value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
 
         return Ok(AnoncredsCredentialDefinition {
             schema_id: cloned_schema_id,
@@ -158,12 +158,12 @@ pub struct CredentialDefinitionPrivate {
 
 impl CredentialDefinitionPrivate {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredentialDefinitionPrivate = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsCredentialDefinitionPrivate = serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(CredentialDefinitionPrivate { core: core_def })
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -177,8 +177,8 @@ impl TryFrom<&CredentialDefinitionPrivate> for AnoncredsCredentialDefinitionPriv
     type Error = AnoncredsError;
 
     fn try_from(def: &CredentialDefinitionPrivate) -> Result<AnoncredsCredentialDefinitionPrivate, Self::Error> {
-        let json_value = serde_json::to_string(&def.core.value).map_err(|_| AnoncredsError::ConversionError)?;
-        return serde_json::from_str(&json_value).map_err(|_| AnoncredsError::ConversionError)
+        let json_value = serde_json::to_string(&def.core.value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
+        return serde_json::from_str(&json_value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -188,12 +188,12 @@ pub struct CredentialKeyCorrectnessProof {
 
 impl CredentialKeyCorrectnessProof {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredentialKeyCorrectnessProof = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsCredentialKeyCorrectnessProof = serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(CredentialKeyCorrectnessProof { core: core_def })
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -207,6 +207,6 @@ impl TryFrom<&CredentialKeyCorrectnessProof> for AnoncredsCredentialKeyCorrectne
     type Error = AnoncredsError;
 
     fn try_from(def: &CredentialKeyCorrectnessProof) -> Result<AnoncredsCredentialKeyCorrectnessProof, Self::Error> {
-        return def.core.try_clone().map_err(|_| AnoncredsError::ConversionError)
+        return def.core.try_clone().map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
diff --git a/uniffi/src/types/cred_offer.rs b/uniffi/src/types/cred_offer.rs
@@ -12,7 +12,7 @@ pub struct CredentialOffer {
 
 impl CredentialOffer {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredentialOffer = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsCredentialOffer = serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(CredentialOffer { core: core_def })
     }
 
@@ -38,7 +38,7 @@ impl CredentialOffer {
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 

diff --git a/uniffi/src/types/cred_req.rs b/uniffi/src/types/cred_req.rs
@@ -10,7 +10,7 @@ pub struct CredentialRequest {
 impl CredentialRequest {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
         let core_def: AnoncredsCredentialRequest =
-            serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+            serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(CredentialRequest { core: core_def });
     }
 
@@ -27,7 +27,7 @@ impl CredentialRequest {
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 

diff --git a/uniffi/src/types/credential.rs b/uniffi/src/types/credential.rs
@@ -11,7 +11,7 @@ pub struct Credential {
 
 impl Credential {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsCredential = serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsCredential = serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(Credential { core: core_def })
     }
 
@@ -48,6 +48,6 @@ impl Credential {
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
diff --git a/uniffi/src/types/error.rs b/uniffi/src/types/error.rs
@@ -2,8 +2,8 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, thiserror::Error, Serialize, Deserialize)]
 pub enum AnoncredsError {
-    #[error("Conversion Error")]
-    ConversionError,
+    #[error("Conversion Error: {0}")]
+    ConversionError(String),
     #[error("Something went wrong")]
     SomethingWentWrong,
     #[error("Create Credential Error: {0}")]

diff --git a/uniffi/src/types/link_secret.rs b/uniffi/src/types/link_secret.rs
@@ -14,7 +14,7 @@ impl LinkSecret {
 
     pub fn new_from_value(value_string: String) -> Result<Self, AnoncredsError> {
         let core_def = AnoncredsLinkSecret::try_from(value_string.as_str())
-            .map_err(|_| AnoncredsError::ConversionError)?;
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(LinkSecret { secret: core_def });
     }
 
@@ -40,7 +40,7 @@ impl TryFrom<&str> for LinkSecret {
 
     fn try_from(string: &str) -> Result<Self, Self::Error> {
         let acr =
-            AnoncredsLinkSecret::try_from(string).map_err(|_| AnoncredsError::ConversionError)?;
+            AnoncredsLinkSecret::try_from(string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(LinkSecret { secret: acr });
     }
 }
@@ -51,7 +51,7 @@ impl TryFrom<&LinkSecret> for AnoncredsLinkSecret {
     fn try_from(acr: &LinkSecret) -> Result<Self, Self::Error> {
         acr.secret
             .try_clone()
-            .map_err(|_| AnoncredsError::ConversionError)
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 

diff --git a/uniffi/src/types/nonce.rs b/uniffi/src/types/nonce.rs
@@ -16,7 +16,7 @@ impl Nonce {
 
     pub fn new_from_value(value_string: String) -> Result<Self, AnoncredsError> {
         let nonce = AnoncredsNonce::try_from(value_string.as_str())
-            .map_err(|_| AnoncredsError::ConversionError)?;
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(Nonce {
             anoncreds_nonce: nonce,
         });
@@ -42,7 +42,7 @@ impl TryFrom<&Nonce> for AnoncredsNonce {
     fn try_from(acr: &Nonce) -> Result<Self, Self::Error> {
         acr.anoncreds_nonce
             .try_clone()
-            .map_err(|_| AnoncredsError::ConversionError)
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -56,7 +56,7 @@ impl TryFrom<&str> for Nonce {
     type Error = AnoncredsError;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let nonce = AnoncredsNonce::try_from(value).map_err(|_| AnoncredsError::ConversionError)?;
+        let nonce = AnoncredsNonce::try_from(value).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(Nonce {
             anoncreds_nonce: nonce,
         });

diff --git a/uniffi/src/types/presentation.rs b/uniffi/src/types/presentation.rs
@@ -9,13 +9,13 @@ pub struct Presentation {
 
 impl Presentation {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
-        let core_def: AnoncredsPresentation =
-            serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+        let core_def: AnoncredsPresentation = serde_json::from_str(&json_string)
+            .map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(Presentation { core: core_def });
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }
 
@@ -26,11 +26,11 @@ pub struct PresentationRequest {
 impl PresentationRequest {
     pub fn new(json_string: String) -> Result<Self, AnoncredsError> {
         let core_def: AnoncredsPresentationRequest =
-            serde_json::from_str(&json_string).map_err(|_| AnoncredsError::ConversionError)?;
+            serde_json::from_str(&json_string).map_err(|err| AnoncredsError::ConversionError(err.to_string()))?;
         return Ok(PresentationRequest { core: core_def });
     }
 
     pub fn get_json(&self) -> Result<String, AnoncredsError> {
-        serde_json::to_string(&self.core).map_err(|_| AnoncredsError::ConversionError)
+        serde_json::to_string(&self.core).map_err(|err| AnoncredsError::ConversionError(err.to_string()))
     }
 }