Skip to main content

libkeri/keri/db/basing/
key_state_record.rs

1use crate::keri::core::serdering::SadValue;
2use crate::keri::KERIError;
3use indexmap::IndexMap;
4use serde::{Deserialize, Serialize};
5use std::default::Default;
6
7/// Corresponds to StateEstEvent namedtuple used as sub record in KeyStateRecord
8/// for latest establishment event associated with current key state
9#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
10pub struct StateEERecord {
11    /// Sequence number of latest est evt lowercase hex no leading zeros
12    #[serde(default = "default_sequence_number")]
13    pub s: String,
14
15    /// SAID qb64 of latest est evt
16    #[serde(default)]
17    pub d: String,
18
19    /// Backer aids qb64 remove list (cuts) from latest est event
20    #[serde(default)]
21    pub br: Option<Vec<String>>,
22
23    /// Backer aids qb64 add list (adds) from latest est event
24    #[serde(default)]
25    pub ba: Option<Vec<String>>,
26}
27
28/// Key State information keyed by Identifier Prefix of associated KEL.
29/// For local AIDs that correspond to Habs this is the Hab AID.
30#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
31pub struct KeyStateRecord {
32    /// Version number [major, minor]
33    #[serde(default)]
34    pub vn: Vec<u8>,
35
36    /// Identifier prefix qb64
37    #[serde(default)]
38    pub i: String,
39
40    /// Sequence number of latest event in KEL as hex str
41    #[serde(default = "default_sequence_number")]
42    pub s: String,
43
44    /// Prior event digest qb64
45    #[serde(default)]
46    pub p: String,
47
48    /// Latest event digest qb64
49    #[serde(default)]
50    pub d: String,
51
52    /// First seen ordinal number of latest event in KEL as hex str
53    #[serde(default = "default_sequence_number")]
54    pub f: String,
55
56    /// Datetime iso-8601 of key state record update, usually now
57    #[serde(default)]
58    pub dt: String,
59
60    /// Latest event packet type (ilk)
61    #[serde(default)]
62    pub et: String,
63
64    /// Signing threshold sith
65    #[serde(default = "default_threshold")]
66    pub kt: String,
67
68    /// Signing keys qb64
69    #[serde(default)]
70    pub k: Vec<String>,
71
72    /// Next prerotated threshold sith
73    #[serde(default = "default_threshold")]
74    pub nt: String,
75
76    /// Pre-rotation keys qb64
77    #[serde(default)]
78    pub n: Vec<String>,
79
80    /// Backer threshold hex num
81    #[serde(default = "default_threshold")]
82    pub bt: String,
83
84    /// Backer aids qb64
85    #[serde(default)]
86    pub b: Vec<String>,
87
88    /// Config traits
89    #[serde(default)]
90    pub c: Vec<String>,
91
92    /// Establishment event record
93    #[serde(default)]
94    pub ee: StateEERecord,
95
96    /// Delegator aid qb64 or empty str if not delegated
97    #[serde(default)]
98    pub di: String,
99}
100
101impl Default for StateEERecord {
102    fn default() -> Self {
103        StateEERecord {
104            s: "0".to_string(),
105            d: "".to_string(),
106            br: None,
107            ba: None,
108        }
109    }
110}
111
112impl Default for KeyStateRecord {
113    fn default() -> Self {
114        KeyStateRecord {
115            vn: Vec::new(),
116            i: "".to_string(),
117            s: "0".to_string(),
118            p: "".to_string(),
119            d: "".to_string(),
120            f: "0".to_string(),
121            dt: "".to_string(),
122            et: "".to_string(),
123            kt: "0".to_string(),
124            k: Vec::new(),
125            nt: "0".to_string(),
126            n: Vec::new(),
127            bt: "0".to_string(),
128            b: Vec::new(),
129            c: Vec::new(),
130            ee: StateEERecord::default(),
131            di: "".to_string(),
132        }
133    }
134}
135
136/// Helper function to provide default value for sequence numbers
137fn default_sequence_number() -> String {
138    "0".to_string()
139}
140
141/// Helper function to provide default value for thresholds
142fn default_threshold() -> String {
143    "0".to_string()
144}
145
146impl StateEERecord {
147    /// Create a new StateEERecord from a StateEstEvent
148    pub fn from_state_est_event(event: &StateEstEvent) -> Result<Self, KERIError> {
149        Ok(StateEERecord {
150            s: event.s.clone(),
151            d: event.d.clone(),
152            br: event.br.clone(),
153            ba: event.ba.clone(),
154        })
155    }
156
157    /// Convert to a map representation
158    pub fn to_map(&self) -> IndexMap<String, SadValue> {
159        let mut map = IndexMap::new();
160        map.insert("s".to_string(), SadValue::String(self.s.clone()));
161        map.insert("d".to_string(), SadValue::String(self.d.clone()));
162        map.insert(
163            "br".to_string(),
164            SadValue::Array(
165                self.br
166                    .clone()
167                    .unwrap()
168                    .iter()
169                    .map(|s| SadValue::String(s.to_string()))
170                    .collect(),
171            ),
172        );
173        map.insert(
174            "ba".to_string(),
175            SadValue::Array(
176                self.ba
177                    .clone()
178                    .unwrap()
179                    .iter()
180                    .map(|s| SadValue::String(s.to_string()))
181                    .collect(),
182            ),
183        );
184
185        map
186    }
187
188    /// Create from a map representation
189    pub fn from_map(map: &IndexMap<String, SadValue>) -> Result<Self, KERIError> {
190        let s = match map.get("s") {
191            Some(SadValue::String(s)) => s.clone(),
192            _ => "0".to_string(),
193        };
194
195        let d = match map.get("d") {
196            Some(SadValue::String(d)) => d.clone(),
197            _ => "".to_string(),
198        };
199
200        let br = match map.get("br") {
201            Some(SadValue::Array(arr)) => {
202                let mut br_vec = Vec::new();
203                for item in arr {
204                    if let SadValue::String(s) = item {
205                        br_vec.push(s.clone());
206                    }
207                }
208                Some(br_vec)
209            }
210            _ => None,
211        };
212
213        let ba = match map.get("ba") {
214            Some(SadValue::Array(arr)) => {
215                let mut ba_vec = Vec::new();
216                for item in arr {
217                    if let SadValue::String(s) = item {
218                        ba_vec.push(s.clone());
219                    }
220                }
221                Some(ba_vec)
222            }
223            _ => None,
224        };
225
226        Ok(StateEERecord { s, d, br, ba })
227    }
228}
229
230impl KeyStateRecord {
231    /// Convert to a map representation
232    pub fn to_map(&self) -> IndexMap<String, SadValue> {
233        let mut map = IndexMap::new();
234        map.insert(
235            "vn".to_string(),
236            SadValue::Array(
237                self.vn
238                    .iter()
239                    .map(|n| SadValue::Number(serde_json::Number::from(*n)))
240                    .collect(),
241            ),
242        );
243        map.insert("i".to_string(), SadValue::String(self.i.clone()));
244        map.insert("s".to_string(), SadValue::String(self.s.clone()));
245        map.insert("p".to_string(), SadValue::String(self.p.clone()));
246        map.insert("d".to_string(), SadValue::String(self.d.clone()));
247        map.insert("f".to_string(), SadValue::String(self.f.clone()));
248        map.insert("dt".to_string(), SadValue::String(self.dt.clone()));
249        map.insert("et".to_string(), SadValue::String(self.et.clone()));
250        map.insert("kt".to_string(), SadValue::String(self.kt.clone()));
251        map.insert(
252            "k".to_string(),
253            SadValue::Array(
254                self.k
255                    .iter()
256                    .map(|s| SadValue::String(s.to_string()))
257                    .collect(),
258            ),
259        );
260        map.insert("nt".to_string(), SadValue::String(self.nt.clone()));
261        map.insert(
262            "n".to_string(),
263            SadValue::Array(
264                self.n
265                    .iter()
266                    .map(|s| SadValue::String(s.to_string()))
267                    .collect(),
268            ),
269        );
270        map.insert("bt".to_string(), SadValue::String(self.bt.clone()));
271        map.insert(
272            "b".to_string(),
273            SadValue::Array(
274                self.b
275                    .iter()
276                    .map(|s| SadValue::String(s.to_string()))
277                    .collect(),
278            ),
279        );
280        map.insert(
281            "c".to_string(),
282            SadValue::Array(
283                self.c
284                    .iter()
285                    .map(|s| SadValue::String(s.to_string()))
286                    .collect(),
287            ),
288        );
289        map.insert("ee".to_string(), SadValue::Object(self.ee.to_map()));
290        map.insert("di".to_string(), SadValue::String(self.di.clone()));
291
292        map
293    }
294
295    /// Create from a map representation
296    pub fn from_map(map: &IndexMap<String, SadValue>) -> Result<Self, KERIError> {
297        let vn = match map.get("vn") {
298            Some(SadValue::Array(arr)) => {
299                let mut vn_vec = Vec::new();
300                for item in arr {
301                    if let SadValue::Number(n) = item {
302                        if let Some(n) = n.as_u64() {
303                            vn_vec.push(n as u8);
304                        }
305                    }
306                }
307                vn_vec
308            }
309            _ => Vec::new(),
310        };
311
312        let i = match map.get("i") {
313            Some(SadValue::String(i)) => i.clone(),
314            _ => "".to_string(),
315        };
316
317        let s = match map.get("s") {
318            Some(SadValue::String(s)) => s.clone(),
319            _ => "0".to_string(),
320        };
321
322        let p = match map.get("p") {
323            Some(SadValue::String(p)) => p.clone(),
324            _ => "".to_string(),
325        };
326
327        let d = match map.get("d") {
328            Some(SadValue::String(d)) => d.clone(),
329            _ => "".to_string(),
330        };
331
332        let f = match map.get("f") {
333            Some(SadValue::String(f)) => f.clone(),
334            _ => "0".to_string(),
335        };
336
337        let dt = match map.get("dt") {
338            Some(SadValue::String(dt)) => dt.clone(),
339            _ => "".to_string(),
340        };
341
342        let et = match map.get("et") {
343            Some(SadValue::String(et)) => et.clone(),
344            _ => "".to_string(),
345        };
346
347        let kt = match map.get("kt") {
348            Some(SadValue::String(kt)) => kt.clone(),
349            _ => "0".to_string(),
350        };
351
352        let k = match map.get("k") {
353            Some(SadValue::Array(arr)) => {
354                let mut k_vec = Vec::new();
355                for item in arr {
356                    if let SadValue::String(s) = item {
357                        k_vec.push(s.clone());
358                    }
359                }
360                k_vec
361            }
362            _ => Vec::new(),
363        };
364
365        let nt = match map.get("nt") {
366            Some(SadValue::String(nt)) => nt.clone(),
367            _ => "0".to_string(),
368        };
369
370        let n = match map.get("n") {
371            Some(SadValue::Array(arr)) => {
372                let mut n_vec = Vec::new();
373                for item in arr {
374                    if let SadValue::String(s) = item {
375                        n_vec.push(s.clone());
376                    }
377                }
378                n_vec
379            }
380            _ => Vec::new(),
381        };
382
383        let bt = match map.get("bt") {
384            Some(SadValue::String(bt)) => bt.clone(),
385            _ => "0".to_string(),
386        };
387
388        let b = match map.get("b") {
389            Some(SadValue::Array(arr)) => {
390                let mut b_vec = Vec::new();
391                for item in arr {
392                    if let SadValue::String(s) = item {
393                        b_vec.push(s.clone());
394                    }
395                }
396                b_vec
397            }
398            _ => Vec::new(),
399        };
400
401        let c = match map.get("c") {
402            Some(SadValue::Array(arr)) => {
403                let mut c_vec = Vec::new();
404                for item in arr {
405                    if let SadValue::String(s) = item {
406                        c_vec.push(s.clone());
407                    }
408                }
409                c_vec
410            }
411            _ => Vec::new(),
412        };
413
414        let ee = match map.get("ee") {
415            Some(SadValue::Object(obj)) => {
416                let ee_map: IndexMap<String, SadValue> =
417                    obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
418                StateEERecord::from_map(&ee_map)?
419            }
420            _ => StateEERecord::default(),
421        };
422
423        let di = match map.get("di") {
424            Some(SadValue::String(di)) => di.clone(),
425            _ => "".to_string(),
426        };
427
428        Ok(KeyStateRecord {
429            vn,
430            i,
431            s,
432            p,
433            d,
434            f,
435            dt,
436            et,
437            kt,
438            k,
439            nt,
440            n,
441            bt,
442            b,
443            c,
444            ee,
445            di,
446        })
447    }
448}
449
450/// StateEstEvent namedtuple equivalent for latest establishment event
451#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
452pub struct StateEstEvent {
453    /// Sequence number of latest est evt lowercase hex no leading zeros
454    pub s: String,
455
456    /// SAID qb64 of latest est evt
457    pub d: String,
458
459    /// Backer aids qb64 remove list (cuts) from latest est event
460    #[serde(default)]
461    pub br: Option<Vec<String>>,
462
463    /// Backer aids qb64 add list (adds) from latest est event
464    #[serde(default)]
465    pub ba: Option<Vec<String>>,
466}
467
468impl Default for StateEstEvent {
469    fn default() -> Self {
470        StateEstEvent {
471            s: "0".to_string(),
472            d: "".to_string(),
473            br: None,
474            ba: None,
475        }
476    }
477}