Initial mobile FFI

trustchain-core/Cargo.toml

@@ -10,6 +10,7 @@ async-trait = "0.1"
 base64 = "0.13"
 canonical_json = "0.4.0"
 chrono = "0.4"
+did-method-key = "0.1.3"
 futures = "0.3.21"
 petgraph = {version = "0.6"}
 serde = { version = "1.0", features = ["derive"] }

trustchain-core/src/resolver.rs

@@ -1,5 +1,6 @@
 //! DID resolution and `DIDResolver` implementation.
 use async_trait::async_trait;
+use did_method_key::DIDKey;
 use serde_json::Value;
 use ssi::did::{DIDMethod, Document, Service, ServiceEndpoint};
 use ssi::did_resolve::{
@@ -108,6 +109,13 @@ impl<T: DIDResolver + Sync + Send> DIDResolver for Resolver<T> {
         Option<Document>,
         Option<DocumentMetadata>,
     ) {
+        // TODO: remove upon handling with DIDMethods
+        if did.starts_with("did:key:") {
+            let did_key_resolver = DIDKey;
+            return did_key_resolver
+                .resolve(did, &ResolutionInputMetadata::default())
+                .await;
+        }
         // Consider using ResolutionInputMetadata to optionally not perform transform.
         // Resolve with the wrapped DIDResolver and then transform to Trustchain format.
         self.transform(self.wrapped_resolver.resolve(did, input_metadata).await)

trustchain-core/src/vp.rs

@@ -21,6 +21,9 @@ pub enum PresentationError {
     /// Wrapped variant for Verifier Error.
     #[error("A wrapped Verifier error: {0}")]
     VerifierError(VerifierError),
+    /// Wrapped variant for SSI Error.
+    #[error("A wrapped SSI error: {0}")]
+    SSIError(ssi::error::Error),
     /// Credentials verified, but holder failed to authenticate with invalid or missing presentation
     /// proof.
     #[error("Credentials verified for an unauthenticated holder: {0:?}")]
@@ -44,3 +47,9 @@ impl From<VerifierError> for PresentationError {
         PresentationError::VerifierError(err)
     }
 }
+
+impl From<ssi::error::Error> for PresentationError {
+    fn from(err: ssi::error::Error) -> Self {
+        PresentationError::SSIError(err)
+    }
+}

trustchain-ffi/Cargo.toml

@@ -15,8 +15,10 @@ trustchain-ion = { path = "../trustchain-ion" }
 trustchain-api = { path = "../trustchain-api" }
 
 anyhow = "1.0"
+chrono = "0.4.26"
 did-ion="0.1.0"
-flutter_rust_bridge = "1"
+# Fixed to same version used to generate bridge: `[email protected]`
+flutter_rust_bridge = "=1.64.0"
 lazy_static="1.4.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

trustchain-ffi/README.md

@@ -0,0 +1,3 @@
+# Trustchain FFI
+
+FFI via [`flutter_rust_bridge`](https://cjycode.com/flutter_rust_bridge/index.html). Example usage can be found in [`trustchain-mobile`](https://github.com/alan-turing-institute/trustchain-mobile/blob/dev/install_trustchain_mobile.md#9-build-trustchain-targets).

trustchain-ffi/src/config.rs

@@ -2,10 +2,12 @@ use anyhow::anyhow;
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use ssi::vc::LinkedDataProofOptions;
-use std::fs;
+use std::{fs, str::FromStr};
 use trustchain_core::TRUSTCHAIN_CONFIG;
 use trustchain_ion::{Endpoint, URL};
 
+use crate::mobile::FFIMobileError;
+
 lazy_static! {
     /// Lazy static reference to ION configuration loaded from `trustchain_config.toml`.
     pub static ref FFI_CONFIG: FFIConfig = parse_toml(
@@ -14,7 +16,7 @@ lazy_static! {
 }
 
 /// Parses and maps ION subfields to a new type.
-fn parse_toml(toml_str: &str) -> FFIConfig {
+pub(crate) fn parse_toml(toml_str: &str) -> FFIConfig {
     toml::from_str::<Config>(toml_str)
         .expect("Error parsing trustchain_config.toml")
         .ffi
@@ -76,19 +78,33 @@ pub struct FFIConfig {
 
 impl FFIConfig {
     pub fn endpoint(&self) -> anyhow::Result<&EndpointOptions> {
-        self.endpoint_options
+        Ok(self
+            .endpoint_options
             .as_ref()
-            .ok_or_else(|| anyhow!("Expected endpoint options."))
+            .ok_or(anyhow!("Expected endpoint options."))
+            .map_err(FFIMobileError::NoConfig)?)
     }
     pub fn trustchain(&self) -> anyhow::Result<&TrustchainOptions> {
-        self.trustchain_options
+        Ok(self
+            .trustchain_options
             .as_ref()
-            .ok_or_else(|| anyhow!("Expected trustchain options."))
+            .ok_or(anyhow!("Expected trustchain options."))
+            .map_err(FFIMobileError::NoConfig)?)
     }
     pub fn linked_data_proof(&self) -> anyhow::Result<&LinkedDataProofOptions> {
-        self.linked_data_proof_options
+        Ok(self
+            .linked_data_proof_options
             .as_ref()
-            .ok_or_else(|| anyhow!("Expected linked data proof options."))
+            .ok_or(anyhow!("Expected linked data proof options."))
+            .map_err(FFIMobileError::NoConfig)?)
+    }
+}
+
+impl FromStr for FFIConfig {
+    type Err = FFIMobileError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_json::from_str(s).map_err(FFIMobileError::FailedToDeserialize)
     }
 }
 
@@ -160,20 +176,19 @@ mod tests {
         let test_mobile_options: String = format!(
             r#"
             {{
-                "endpointOptions": {},
-                "trustchainOptions": {},
-                "linkedDataProofOptions": {}
+                "endpointOptions": {TEST_ENDPOINT_OPTIONS},
+                "trustchainOptions": {TEST_TRUSTCHAIN_OPTIONS},
+                "linkedDataProofOptions": {TEST_LINKED_DATA_PROOF_OPTIONS}
             }}
         "#,
-            TEST_ENDPOINT_OPTIONS, TEST_TRUSTCHAIN_OPTIONS, TEST_LINKED_DATA_PROOF_OPTIONS
         );
         serde_json::from_str::<FFIConfig>(&test_mobile_options).unwrap();
     }
     #[test]
     fn test_ffi_options_from_toml() {
-        println!("{:?}", parse_toml(&TEST_FFI_OPTIONS));
+        println!("{:?}", parse_toml(TEST_FFI_OPTIONS));
         assert_eq!(
-            parse_toml(&TEST_FFI_OPTIONS)
+            parse_toml(TEST_FFI_OPTIONS)
                 .endpoint()
                 .unwrap()
                 .trustchain_endpoint()
@@ -182,7 +197,7 @@ mod tests {
             8081
         );
         assert_eq!(
-            parse_toml(&TEST_FFI_OPTIONS)
+            parse_toml(TEST_FFI_OPTIONS)
                 .linked_data_proof()
                 .unwrap()
                 .proof_purpose

trustchain-ffi/src/gui.rs

@@ -55,9 +55,9 @@ fn attest(did: String, controlled_did: String, verbose: bool) -> anyhow::Result<
 /// Resolves a given DID using a resolver available at localhost:3000
 fn resolve(did: String, verbose: bool) -> anyhow::Result<String> {
     let rt = Runtime::new().unwrap();
+    let resolver = get_ion_resolver("http://localhost:3000/");
     rt.block_on(async {
-        let (res_meta, doc, doc_meta) =
-            TrustchainAPI::resolve(&did, "http://localhost:3000/".into()).await?;
+        let (res_meta, doc, doc_meta) = TrustchainAPI::resolve(&did, &resolver).await?;
         // TODO: refactor conversion into trustchain-core resolve module
         Ok(serde_json::to_string_pretty(&ResolutionResult {
             context: Some(serde_json::Value::String(

trustchain-ffi/src/lib.rs

@@ -1,4 +1,4 @@
 pub mod config;
-// TODO: uncomment on gui and mobile feature branches
 // pub mod gui;
-// pub mod mobile;
+pub mod mobile;
+mod mobile_bridge;