xdid-core 0.8.0

Core types for DID methods to implement.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use std::str::FromStr;

use serde_json::Value;
use xdid_core::{
    did::Did,
    did_url::{
        relative::{
            RelativeDidUrl,
            RelativeDidUrlPath,
        },
        url::DidUrl,
    },
    document::{
        Document,
        VerificationMethod,
        VerificationMethodMap,
    },
};

#[test]
fn test_document_serde() {
    const EXPECTED_RAW: &[u8] = include_bytes!("./document-expected.json");

    let did = Did::from_str("did:web:localhost%3A4000").expect("valid DID");

    let owner = DidUrl::new(did.clone(), None, None, Some("owner".into())).expect("valid DID URL");

    let doc = Document {
        context:               None,
        id:                    did.clone(),
        also_known_as:         None,
        assertion_method:      Some(vec![VerificationMethod::RelativeUrl(
            RelativeDidUrl::new(RelativeDidUrlPath::Empty, None, Some("owner".into()))
                .expect("valid relative DID URL"),
        )]),
        authentication:        None,
        capability_delegation: Some(vec![VerificationMethod::Url(
            DidUrl::new(
                did.clone(),
                None,
                Some("test-query".into()),
                Some("owner".into()),
            )
            .expect("valid DID URL"),
        )]),
        capability_invocation: None,
        controller:            None,
        key_agreement:         None,
        service:               None,
        verification_method:   Some(vec![VerificationMethodMap {
            id:                   owner,
            controller:           did,
            typ:                  "JsonWebKey2020".into(),
            public_key_multibase: None,
            public_key_jwk:       None,
        }]),
    };

    let doc_val = serde_json::to_value(&doc).expect("serialization should succeed");
    println!(
        "{}",
        serde_json::to_string_pretty(&doc).expect("serialization should succeed")
    );

    let expected_val: Value =
        serde_json::from_slice(EXPECTED_RAW).expect("deserialization should succeed");
    assert_eq!(doc_val, expected_val);

    let expected_doc: Document =
        serde_json::from_slice(EXPECTED_RAW).expect("deserialization should succeed");
    assert_eq!(doc, expected_doc);
}