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

use serde::{Deserialize, Serialize};

mod pack;
mod unpack;

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
/// `from_prior` header value as a plaintext.
/// https://identity.foundation/didcomm-messaging/spec/#did-rotation
pub struct FromPrior {
    pub iss: String,

    pub sub: String,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub aud: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub exp: Option<u64>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub nbf: Option<u64>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub iat: Option<u64>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub jti: Option<String>,
}

const JWT_TYP: &str = "JWT";

impl FromPrior {
    pub fn build(iss: String, sub: String) -> FromPriorBuilder {
        FromPriorBuilder::new(iss, sub)
    }
}

pub struct FromPriorBuilder {
    iss: String,
    sub: String,
    aud: Option<String>,
    exp: Option<u64>,
    nbf: Option<u64>,
    iat: Option<u64>,
    jti: Option<String>,
}

impl FromPriorBuilder {
    fn new(iss: String, sub: String) -> Self {
        FromPriorBuilder {
            iss,
            sub,
            aud: None,
            exp: None,
            nbf: None,
            iat: None,
            jti: None,
        }
    }

    pub fn aud(mut self, aud: String) -> Self {
        self.aud = Some(aud);
        self
    }

    pub fn exp(mut self, exp: u64) -> Self {
        self.exp = Some(exp);
        self
    }

    pub fn nbf(mut self, nbf: u64) -> Self {
        self.nbf = Some(nbf);
        self
    }

    pub fn iat(mut self, iat: u64) -> Self {
        self.iat = Some(iat);
        self
    }

    pub fn jti(mut self, jti: String) -> Self {
        self.jti = Some(jti);
        self
    }

    pub fn finalize(self) -> FromPrior {
        FromPrior {
            iss: self.iss,
            sub: self.sub,
            aud: self.aud,
            exp: self.exp,
            nbf: self.nbf,
            iat: self.iat,
            jti: self.jti,
        }
    }
}