Skip to main content

libkeri/keri/core/eventing/
interact.rs

1use crate::cesr::number::Number;
2use crate::cesr::Versionage;
3use crate::keri::core::serdering::{SadValue, SerderKERI};
4use crate::keri::{versify, Ilks, KERIError, Kinds};
5use indexmap::IndexMap;
6use num_bigint::BigUint;
7
8/// Builder for creating KERI interaction events
9pub struct InteractEventBuilder {
10    pre: String,
11    dig: String,
12    sn: usize,
13    data_list: Option<Vec<SadValue>>,
14    data_map: Option<IndexMap<String, SadValue>>,
15    version: String,
16    kind: String,
17}
18
19impl InteractEventBuilder {
20    /// Create a new InteractEventBuilder with required fields
21    pub fn new(pre: String, dig: String) -> Self {
22        Self {
23            pre,
24            dig,
25            sn: 1,
26            data_list: None,
27            data_map: None,
28            version: "KERI10JSON000000_".to_string(),
29            kind: "JSON".to_string(),
30        }
31    }
32
33    /// Set the sequence number
34    pub fn with_sn(mut self, sn: usize) -> Self {
35        self.sn = sn;
36        self
37    }
38
39    /// Set the committed data (such as seals)
40    pub fn with_data_list(mut self, data: Vec<SadValue>) -> Self {
41        self.data_list = Some(data);
42        self
43    }
44
45    /// Set the committed data (such as seals)
46    pub fn with_data_map(mut self, data: IndexMap<String, SadValue>) -> Self {
47        self.data_map = Some(data);
48        self
49    }
50
51    /// Set the version string
52    pub fn with_version(mut self, version: String) -> Self {
53        self.version = version;
54        self
55    }
56
57    /// Set the serialization kind
58    pub fn with_kind(mut self, kind: String) -> Self {
59        self.kind = kind;
60        self
61    }
62
63    /// Build the interaction event serder
64    pub fn build(self) -> Result<SerderKERI, KERIError> {
65        // Validate sequence number
66        let sner = Number::from_num(&BigUint::from(self.sn))?;
67        if sner.num() < 1 {
68            return Err(KERIError::ValueError(format!(
69                "Invalid sn = 0x{} for ixn.",
70                sner.numh()
71            )));
72        }
73
74        if !Kinds::contains(&self.kind) {
75            return Err(KERIError::ValueError(format!(
76                "Invalid kind = {} for ixn.",
77                self.kind
78            )));
79        }
80        // Create versified string
81        let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
82
83        // Create the key event dict (ked)
84        let mut ked = IndexMap::new();
85        ked.insert("v".to_string(), SadValue::String(vs));
86        ked.insert("t".to_string(), SadValue::String(Ilks::IXN.to_string()));
87        ked.insert("d".to_string(), SadValue::String("".to_string()));
88        ked.insert("i".to_string(), SadValue::String(self.pre));
89        ked.insert("s".to_string(), SadValue::String(sner.numh()));
90        ked.insert("p".to_string(), SadValue::String(self.dig));
91
92        if self.data_list.is_some() {
93            ked.insert("a".to_string(), SadValue::Array(self.data_list.unwrap()));
94        } else if self.data_map.is_some() {
95            ked.insert("a".to_string(), SadValue::Object(self.data_map.unwrap()));
96        } else {
97            ked.insert("a".to_string(), SadValue::Array(vec![]));
98        }
99
100        // Create the serder
101        let serder = SerderKERI::from_sad_and_saids(&ked, None)?;
102        Ok(serder)
103    }
104}
105
106#[cfg(test)]
107mod tests {
108    use super::*;
109    use crate::keri::core::serdering::Serder;
110    use std::error::Error;
111
112    #[test]
113    fn test_interact_event_builder_basic() -> Result<(), Box<dyn Error>> {
114        // Create identifier prefix
115        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
116
117        // Create previous event digest
118        let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
119
120        // Create a basic interaction
121        let serder = InteractEventBuilder::new(pre.clone(), dig.clone()).build()?;
122
123        // Verify the key event data
124        let ked = serder.ked();
125
126        // Check it's an interaction event
127        assert_eq!(ked["t"].as_str().unwrap(), Ilks::IXN);
128
129        // Check basic fields
130        assert_eq!(ked["i"].as_str().unwrap(), pre);
131        assert_eq!(ked["p"].as_str().unwrap(), dig);
132        assert_eq!(ked["s"].as_str().unwrap(), "1");
133
134        // Check the attachments array is empty
135        let attachments = ked["a"].as_array().unwrap();
136        assert!(attachments.is_empty());
137
138        Ok(())
139    }
140
141    #[test]
142    fn test_interact_event_builder_with_data() -> Result<(), Box<dyn Error>> {
143        // Create identifier prefix
144        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
145
146        // Create previous event digest
147        let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
148
149        // Create data attachments
150        let mut data_map1 = IndexMap::new();
151        data_map1.insert(
152            "i".to_string(),
153            SadValue::String("EbAwspDmOlHDUjGZ8m9JGQ4r7Knt5gu4KBNt0JSL2ZoI".to_string()),
154        );
155        data_map1.insert("s".to_string(), SadValue::String("3".to_string()));
156        data_map1.insert(
157            "d".to_string(),
158            SadValue::String("EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string()),
159        );
160
161        let mut data_map2 = IndexMap::new();
162        data_map2.insert(
163            "i".to_string(),
164            SadValue::String("ELPNqidJsVsWPAPb5RkJKS7wEzOvE9ihzhTFcmF8vEHM".to_string()),
165        );
166        data_map2.insert("s".to_string(), SadValue::String("1".to_string()));
167        data_map2.insert(
168            "d".to_string(),
169            SadValue::String("EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string()),
170        );
171
172        let data = vec![
173            SadValue::from(SadValue::Object(data_map1)),
174            SadValue::from(SadValue::Object(data_map2)),
175        ];
176
177        // Create an interaction with data and sequence number 2
178        let serder = InteractEventBuilder::new(pre.clone(), dig.clone())
179            .with_sn(2)
180            .with_data_list(data)
181            .build()?;
182
183        // Verify the key event data
184        let ked = serder.ked();
185
186        // Check it's an interaction event
187        assert_eq!(ked["t"].as_str().unwrap(), Ilks::IXN);
188
189        // Check basic fields
190        assert_eq!(ked["i"].as_str().unwrap(), pre);
191        assert_eq!(ked["p"].as_str().unwrap(), dig);
192        assert_eq!(ked["s"].as_str().unwrap(), "2");
193
194        // Check the attachments
195        let attachments = ked["a"].as_array().unwrap();
196        assert_eq!(attachments.len(), 2);
197
198        // Check first attachment
199        let first_attachment = &attachments[0];
200        match first_attachment {
201            SadValue::Object(m) => {
202                assert_eq!(
203                    m["i"].as_str().unwrap(),
204                    "EbAwspDmOlHDUjGZ8m9JGQ4r7Knt5gu4KBNt0JSL2ZoI"
205                );
206            }
207            _ => {
208                panic!("Expected attachment to be an object");
209            }
210        }
211
212        // Check second attachment
213        let second_attachment = &attachments[1];
214        match second_attachment {
215            SadValue::Object(m) => {
216                assert_eq!(
217                    m["i"].as_str().unwrap(),
218                    "ELPNqidJsVsWPAPb5RkJKS7wEzOvE9ihzhTFcmF8vEHM"
219                );
220            }
221            _ => {
222                panic!("Expected attachment to be an object");
223            }
224        }
225
226        Ok(())
227    }
228
229    #[test]
230    fn test_interact_event_builder_invalid_sn() -> Result<(), Box<dyn Error>> {
231        // Create identifier prefix
232        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
233
234        // Create previous event digest
235        let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
236
237        // Try to create an interaction with invalid sequence number
238        let result = InteractEventBuilder::new(pre.clone(), dig.clone())
239            .with_sn(0)
240            .build();
241
242        // Should fail with error about invalid sequence number
243        assert!(result.is_err());
244        let err = result.unwrap_err();
245        assert!(err.to_string().contains("Invalid sn"));
246
247        Ok(())
248    }
249
250    #[test]
251    fn test_interact_event_builder_version_and_kind() -> Result<(), Box<dyn Error>> {
252        // Create identifier prefix
253        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
254
255        // Create previous event digest
256        let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
257
258        // Create an interaction with custom version and kind
259        let serder = InteractEventBuilder::new(pre.clone(), dig.clone())
260            .with_version("KERI10".to_string())
261            .with_kind("CBOR".to_string())
262            .build()?;
263
264        // Verify the key event data
265        let ked = serder.ked();
266
267        // Check version string starts with KERI10CBOR
268        let kver = ked["v"].as_str().unwrap();
269        assert!(kver.starts_with("KERI10CBOR"));
270
271        Ok(())
272    }
273
274    #[test]
275    fn test_interact_event_said_derivation() -> Result<(), Box<dyn Error>> {
276        // Create identifier prefix
277        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
278
279        // Create previous event digest
280        let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
281
282        // Create an interaction
283        let serder = InteractEventBuilder::new(pre.clone(), dig.clone()).build()?;
284
285        // Get the SAID (self-addressing identifier)
286        let said = serder.said().expect("Failed to get SAID");
287
288        // SAID should start with 'E' for BLAKE3_256 digest
289        assert!(said.starts_with('E'));
290
291        // Verify the SAID is in the 'd' field of the event
292        assert_eq!(serder.ked()["d"].as_str().unwrap(), said);
293
294        Ok(())
295    }
296
297    #[test]
298    fn test_interactaction() -> Result<(), Box<dyn Error>> {
299        let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH";
300        let pdig = "ECauhEzA4DJDXVDnNQiGQ0sKXa6sx_GgS8Ebdzm4E-kQ";
301
302        let serder = InteractEventBuilder::new(pre.to_string(), pdig.to_string())
303            .with_sn(2)
304            .build()?;
305
306        let ked = serder.ked();
307
308        assert_eq!(ked["t"].as_str().unwrap(), Ilks::IXN.to_string());
309        assert_eq!(ked["s"].as_str().unwrap(), "2");
310        assert_eq!(ked["i"].as_str().unwrap(), pre);
311        assert_eq!(ked["p"].as_str().unwrap(), pdig);
312
313        let raw = b"{\"v\":\"KERI10JSON0000cb_\",\"t\":\"ixn\",\"d\":\"EKKccCumVQdgxvsrSXvuTtjmS28Xqf3zRJ8T6peKgl9J\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"2\",\"p\":\"ECauhEzA4DJDXVDnNQiGQ0sKXa6sx_GgS8Ebdzm4E-kQ\",\"a\":[]}";
314        assert_eq!(serder.raw(), raw);
315
316        Ok(())
317    }
318}