Create and resolve did:jwk (#20)

Cargo.toml

@@ -14,4 +14,7 @@ repository = "https://github.com/TBD54566975/web5-rs.git"
 license-file = "LICENSE"
 
 [workspace.dependencies]
-thiserror = "1.0.50"
+thiserror = "1.0.50"
+serde = { version = "1.0.193", features = ["derive"] }
+serde_json = "1.0.108"
+serde_with = "3.4.0"

crates/credentials/Cargo.toml

@@ -8,9 +8,9 @@ license-file.workspace = true
 
 [dependencies]
 jsonschema = "0.17.1"
-serde = { version = "1.0.193", features = ["derive"] }
-serde_json = "1.0.108"
-serde_with = "3.4.0"
+serde = { workspace = true }
+serde_json = { workspace = true }
+serde_with = { workspace = true }
 
 [dev-dependencies]
 serde_canonical_json = "1.0.0"

crates/dids/Cargo.toml

@@ -2,7 +2,18 @@
 name = "dids"
 version = "0.1.0"
 edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+homepage.workspace = true
+repository.workspace = true
+license-file.workspace = true
 
 [dependencies]
+async-trait = "0.1.74"
+crypto = { path = "../crypto" }
+did-jwk = "0.1.1"
+serde = { workspace = true }
+serde_json = { workspace = true }
+ssi-dids = "0.1.1"
+thiserror = { workspace = true }
+
+[dev-dependencies]
+tokio = { version = "1.34.0", features = ["macros", "test-util"] }

crates/dids/src/did.rs

@@ -0,0 +1,21 @@
+use crate::resolver::{DidResolutionResult, DidResolver};
+use async_trait::async_trait;
+use crypto::key_manager::KeyManager;
+use std::sync::Arc;
+
+/// Trait that defines all common behavior for a DID.
+#[async_trait]
+pub trait Did {
+ /// Returns the DID URI the target [`Did`] represents (e.g: `did:jwk:12345`).
+ fn uri(&self) -> &str;
+
+ /// Returns a reference to the [`KeyManager`] that contains all the keys necessary to
+ /// manage and sign using the target [`Did`].
+ fn key_manager(&self) -> &Arc<dyn KeyManager>;
+
+ /// Returns a [`DidResolutionResult`] for the target [`Did`], as specified in
+ /// [Resolving a DID](https://w3c-ccg.github.io/did-resolution/#resolving).
+ async fn resolve(&self) -> DidResolutionResult {
+ DidResolver::resolve_uri(self.uri()).await
+ }
+}

crates/dids/src/lib.rs

@@ -1,14 +1,3 @@
-pub fn add(left: usize, right: usize) -> usize {
- left + right
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn it_works() {
- let result = add(2, 2);
- assert_eq!(result, 4);
- }
-}
+pub mod did;
+pub mod method;
+pub mod resolver;

crates/dids/src/method/jwk.rs

@@ -0,0 +1,120 @@
+use crate::did::Did;
+use crate::method::{DidMethod, DidMethodError};
+use crate::resolver::DidResolutionResult;
+use async_trait::async_trait;
+use crypto::key::{Key, KeyType};
+use crypto::key_manager::KeyManager;
+use did_jwk::DIDJWK as SpruceDidJwkMethod;
+use ssi_dids::did_resolve::{DIDResolver, ResolutionInputMetadata};
+use ssi_dids::{DIDMethod, Source};
+use std::sync::Arc;
+
+/// Concrete implementation for a did:jwk DID
+pub struct DidJwk {
+ uri: String,
+ key_manager: Arc<dyn KeyManager>,
+}
+
+impl Did for DidJwk {
+ fn uri(&self) -> &str {
+ &self.uri
+ }
+
+ fn key_manager(&self) -> &Arc<dyn KeyManager> {
+ &self.key_manager
+ }
+}
+
+/// Options that can be used to create a did:jwk DID
+pub struct DidJwkCreateOptions {
+ pub key_type: KeyType,
+}
+
+#[async_trait]
+impl DidMethod<DidJwk, DidJwkCreateOptions> for DidJwk {
+ const NAME: &'static str = "jwk";
+
+ fn create(
+ key_manager: Arc<dyn KeyManager>,
+ options: DidJwkCreateOptions,
+ ) -> Result<DidJwk, DidMethodError> {
+ let key_alias = key_manager.generate_private_key(options.key_type)?;
+ let public_key =
+ key_manager
+ .get_public_key(&key_alias)?
+ .ok_or(DidMethodError::DidCreationFailure(
+ "PublicKey not found".to_string(),
+ ))?;
+
+ let uri = SpruceDidJwkMethod
+ .generate(&Source::Key(&public_key.jwk()))
+ .ok_or(DidMethodError::DidCreationFailure(
+ "Failed to generate did:jwk".to_string(),
+ ))?;
+
+ Ok(DidJwk { uri, key_manager })
+ }
+
+ async fn resolve_uri(did_uri: &str) -> DidResolutionResult {
+ let input_metadata = ResolutionInputMetadata::default();
+ let (did_resolution_metadata, did_document, did_document_metadata) =
+ SpruceDidJwkMethod.resolve(did_uri, &input_metadata).await;
+
+ DidResolutionResult {
+ did_resolution_metadata,
+ did_document,
+ did_document_metadata,
+ ..Default::default()
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use ssi_dids::did_resolve::ERROR_INVALID_DID;
+
+ fn create_did_jwk() -> DidJwk {
+ let key_manager = Arc::new(crypto::key_manager::LocalKeyManager::new_in_memory());
+ let options = DidJwkCreateOptions {
+ key_type: KeyType::Ed25519,
+ };
+
+ DidJwk::create(key_manager, options).unwrap()
+ }
+
+ #[test]
+ fn create_produces_correct_uri() {
+ let did = create_did_jwk();
+ assert!(did.uri.starts_with("did:jwk:"));
+ }
+
+ #[tokio::test]
+ async fn instance_resolve() {
+ let did = create_did_jwk();
+ let result = did.resolve().await;
+ assert!(result.did_resolution_metadata.error.is_none());
+
+ let did_document = result.did_document.unwrap();
+ assert_eq!(did_document.id, did.uri);
+ }
+
+ #[tokio::test]
+ async fn resolve_uri_success() {
+ let did = create_did_jwk();
+ let result = DidJwk::resolve_uri(&did.uri).await;
+ assert!(result.did_resolution_metadata.error.is_none());
+
+ let did_document = result.did_document.unwrap();
+ assert_eq!(did_document.id, did.uri);
+ }
+
+ #[tokio::test]
+ async fn resolve_uri_failure() {
+ let result = DidJwk::resolve_uri("did:jwk:does-not-exist").await;
+ assert_eq!(
+ result.did_resolution_metadata.error,
+ Some(ERROR_INVALID_DID.to_string())
+ );
+ }
+}

crates/dids/src/method/mod.rs

@@ -0,0 +1,41 @@
+pub mod jwk;
+
+use crate::did::Did;
+use crate::resolver::DidResolutionResult;
+use async_trait::async_trait;
+use crypto::key_manager::{KeyManager, KeyManagerError};
+use std::sync::Arc;
+
+/// Errors that can occur when working with DID methods.
+#[derive(thiserror::Error, Debug)]
+pub enum DidMethodError {
+ #[error(transparent)]
+ KeyManagerError(#[from] KeyManagerError),
+ #[error("Failure creating DID: {0}")]
+ DidCreationFailure(String),
+}
+
+/// A trait with common behavior across all DID methods.
+#[async_trait]
+pub trait DidMethod<T: Did, CreateOptions> {
+ /// The name of the implemented DID method (e.g. `jwk`).
+ ///
+ /// This is used to identify the [`DidMethod`] responsible for creating/resolving an arbitrary
+ /// DID URI.
+ ///
+ /// # Example
+ /// If a consumer wants to resolve a DID URI of `did:jwk:12345`, the method portion of the URI
+ /// (`jwk` in this example) is compared against each [`DidMethod`]'s `NAME` constant. If a match
+ /// is found, the corresponding [`DidMethod`] is used to resolve the DID URI.
+ const NAME: &'static str;
+
+ /// Create a new DID instance.
+ fn create(
+ key_manager: Arc<dyn KeyManager>,
+ options: CreateOptions,
+ ) -> Result<T, DidMethodError>;
+
+ /// Resolve a DID URI to a [`DidResolutionResult`], as specified in
+ /// [Resolving a DID](https://w3c-ccg.github.io/did-resolution/#resolving).
+ async fn resolve_uri(did_uri: &str) -> DidResolutionResult;
+}

crates/dids/src/resolver.rs

@@ -0,0 +1,109 @@
+use crate::method::jwk::DidJwk;
+use crate::method::DidMethod;
+use serde::{Deserialize, Serialize};
+use ssi_dids::did_resolve::{
+ DocumentMetadata as DidDocumentMetadata, ResolutionMetadata as DidResolutionMetadata,
+};
+use ssi_dids::Document as DidDocument;
+
+pub struct DidResolver;
+
+impl DidResolver {
+ /// Resolves a DID URI, using the appropriate DID method, to a DID Document.
+ pub async fn resolve_uri(did_uri: &str) -> DidResolutionResult {
+ let method_name = match DidResolver::method_name(did_uri) {
+ Some(method_name) => method_name,
+ None => return DidResolutionResult::from_error(ERROR_INVALID_DID),
+ };
+
+ match method_name {
+ DidJwk::NAME => DidJwk::resolve_uri(did_uri).await,
+ _ => return DidResolutionResult::from_error(ERROR_METHOD_NOT_SUPPORTED),
+ }
+ }
+
+ /// Returns the method name of a DID URI, if the provided DID URI is valid, `None` otherwise.
+ fn method_name(did_uri: &str) -> Option<&str> {
+ let parts: Vec<&str> = did_uri.split(':').collect();
+ if parts.len() < 3 || parts[0] != "did" {
+ return None;
+ };
+
+ Some(parts[1])
+ }
+}
+
+/// Result of a DID resolution.
+///
+/// See [Resolving a DID](https://w3c-ccg.github.io/did-resolution/#resolving) for more information
+/// about the resolution process, and documentation around expected results formats in the case
+/// there was an error resolving the DID.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct DidResolutionResult {
+ #[serde(rename = "@context")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub context: Option<String>,
+ pub did_resolution_metadata: DidResolutionMetadata,
+ pub did_document: Option<DidDocument>,
+ pub did_document_metadata: Option<DidDocumentMetadata>,
+}
+
+const DID_RESOLUTION_V1_CONTEXT: &str = "https://w3id.org/did-resolution/v1";
+const ERROR_METHOD_NOT_SUPPORTED: &str = "methodNotSupported";
+const ERROR_INVALID_DID: &str = "invalidDid";
+
+impl Default for DidResolutionResult {
+ fn default() -> Self {
+ Self {
+ context: Some(DID_RESOLUTION_V1_CONTEXT.to_string()),
+ did_resolution_metadata: DidResolutionMetadata::default(),
+ did_document: None,
+ did_document_metadata: None,
+ }
+ }
+}
+
+impl DidResolutionResult {
+ /// Convenience method for creating a DidResolutionResult with an error.
+ pub fn from_error(err: &str) -> Self {
+ Self {
+ did_resolution_metadata: DidResolutionMetadata::from_error(err),
+ ..Default::default()
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[tokio::test]
+ async fn resolve_did_jwk() {
+ let did_uri = "did:jwk:eyJjcnYiOiJQLTI1NiIsImt0eSI6IkVDIiwieCI6ImFjYklRaXVNczNpOF91c3pFakoydHBUdFJNNEVVM3l6OTFQSDZDZEgyVjAiLCJ5IjoiX0tjeUxqOXZXTXB0bm1LdG00NkdxRHo4d2Y3NEk1TEtncmwyR3pIM25TRSJ9";
+ let result = DidResolver::resolve_uri(did_uri).await;
+ assert!(result.did_resolution_metadata.error.is_none());
+
+ let did_document = result.did_document.unwrap();
+ assert_eq!(did_document.id, did_uri);
+ }
+
+ #[tokio::test]
+ async fn resolve_invalid_did() {
+ let did_uri = "did:jwk";
+ let result = DidResolver::resolve_uri(did_uri).await;
+ assert_eq!(
+ result.did_resolution_metadata.error,
+ Some(ERROR_INVALID_DID.to_string())
+ );
+ }
+
+ #[tokio::test]
+ async fn resolve_unsupported_method() {
+ let did_uri = "did:unsupported:1234";
+ let result = DidResolver::resolve_uri(did_uri).await;
+ assert_eq!(
+ result.did_resolution_metadata.error,
+ Some(ERROR_METHOD_NOT_SUPPORTED.to_string())
+ );
+ }
+}