didcomm 0.4.1

DIDComm for Rust
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

mod jwe;
mod jwk;
mod jws;
mod message;
mod utils;

// Allows share test vectors between unit and integration tests
#[cfg(test)]
pub(crate) use crate as didcomm;

#[cfg(test)]
mod test_vectors;

#[cfg(feature = "testvectors")]
pub(crate) use crate as didcomm;

#[cfg(feature = "testvectors")]
pub mod test_vectors;

pub mod algorithms;
pub mod did;
pub mod error;
pub mod protocols;
pub mod secrets;

pub use message::{
    Attachment, AttachmentBuilder, AttachmentData, Base64AttachmentData, FromPrior,
    JsonAttachmentData, LinksAttachmentData, Message, MessageBuilder, MessagingServiceMetadata,
    PackEncryptedMetadata, PackEncryptedOptions, PackSignedMetadata, UnpackMetadata, UnpackOptions,
};

#[cfg(test)]
mod tests {
    use serde_json::json;

    use crate::{
        did::resolvers::ExampleDIDResolver, secrets::resolvers::ExampleSecretsResolver, Message,
        PackEncryptedOptions, UnpackOptions,
    };

    #[tokio::test]
    #[ignore = "will be fixed after https://github.com/sicpa-dlab/didcomm-gemini/issues/71"]
    async fn demo_works() {
        // --- Build message ---

        let sender = "did:example:1";
        let recipient = "did:example:2";

        let msg = Message::build(
            "example-1".into(),
            "example/v1".into(),
            json!("example-body"),
        )
        .to(recipient.into())
        .from(sender.into())
        .finalize();

        // --- Packing message ---

        let sender_did_resolver = ExampleDIDResolver::new(vec![]);
        let sender_secrets_resolver = ExampleSecretsResolver::new(vec![]);

        let (packed_msg, metadata) = msg
            .pack_encrypted(
                recipient,
                Some(sender),
                None,
                &sender_did_resolver,
                &sender_secrets_resolver,
                &PackEncryptedOptions::default(),
            )
            .await
            .expect("pack is ok.");

        // --- Send message using service endpoint ---

        let service_endpoint = metadata
            .messaging_service
            .expect("messagin service present.")
            .service_endpoint;

        println!("Sending message {} throug {}", packed_msg, service_endpoint);

        // --- Unpacking message ---

        let recipient_did_resolver = ExampleDIDResolver::new(vec![]);
        let recipient_secrets_resolver = ExampleSecretsResolver::new(vec![]);

        let (msg, metadata) = Message::unpack(
            &packed_msg,
            &recipient_did_resolver,
            &recipient_secrets_resolver,
            &UnpackOptions::default(),
        )
        .await
        .expect("unpack is ok.");

        assert!(metadata.encrypted);
        assert!(metadata.authenticated);
        assert!(metadata.encrypted_from_kid.is_some());
        assert!(metadata.encrypted_from_kid.unwrap().starts_with(&recipient));

        assert_eq!(msg.from, Some(sender.into()));
        assert_eq!(msg.to, Some(vec![recipient.into()]));
        assert_eq!(msg.body, json!("example-body"));
    }
}