Skip to main content

libkeri/keri/core/
mod.rs

1pub mod errors;
2pub mod eventing;
3pub mod filing;
4pub mod parsing;
5pub mod routing;
6pub mod serdering;
7
8use regex::bytes::Regex;
9
10use once_cell::sync::Lazy;
11
12use crate::cesr::Versionage;
13use crate::errors::MatterError;
14use crate::keri::core::serdering::{SadValue, Sadder};
15use crate::keri::{deversify, versify, KERIError, Kinds};
16
17/// Regex to find version string in raw serialization
18static REVER: Lazy<Regex> = Lazy::new(|| {
19    Regex::new(r"(?P<proto1>[A-Z]{4})(?P<major1>[0-9a-f])(?P<minor1>[0-9a-f])(?P<kind1>[A-Z]{4})(?P<size1>[0-9a-f]{6})_").expect("Invalid regex pattern")
20});
21
22/// Compute serialized size of ked and update version field
23///
24/// Returns tuple of (raw, proto, kind, ked, version) where:
25///   * raw (Vec<u8>): serialized event as bytes of kind
26///   * proto (String): protocol type as value of Protocolage
27///   * kind (String): serialization kind as value of Serialage
28///   * ked (Sadder): key event dict (with updated version string)
29///   * version (Versionage): instance
30///
31/// # Parameters
32///   * ked (Sadder): key event dict
33///   * kind_opt (Option<Kinds>): value of Kinds is serialization type
34///       if not provided use that given in ked.v
35///   * version_opt (Option<Versionage>): supported protocol version for message
36///
37/// # Errors
38///   * MatterError: if version string is missing, unsupported version,
39///     invalid kind, or malformed version string
40pub fn sizeify(
41    ked: &Sadder,
42    kind_opt: Option<&Kinds>,
43    version_opt: Option<Versionage>,
44) -> Result<(Vec<u8>, String, String, Sadder, Versionage), KERIError> {
45    // Get the default version if not provided
46    let version = version_opt.unwrap_or_else(|| Versionage { major: 1, minor: 0 });
47
48    // Check if 'v' field exists in ked
49    if !ked.contains_key("v") {
50        return Err(MatterError::ValueError(
51            "Missing version string in key event dict".to_string(),
52        )
53        .into());
54    }
55
56    // Extract protocol, version, kind, and size from version string
57    let smellage = deversify(ked["v"].as_str().unwrap())?;
58    let (proto, vrsn, knd) = (smellage.proto, smellage.vrsn, smellage.kind);
59
60    // Verify version is supported
61    if vrsn != version {
62        return Err(KERIError::ValueError(format!(
63            "Unsupported version = {}.{}",
64            vrsn.major, vrsn.minor
65        )));
66    }
67
68    // Use provided kind or extracted kind
69    let kind = match kind_opt {
70        Some(k) => k,
71        None => &Kinds::from(&knd)?,
72    };
73
74    // Create a copy of ked to update the version string
75    let mut ked_mut = ked.clone();
76
77    // Serialize ked to get raw bytes
78    let raw = SadValue::dumps(&ked_mut, &kind)?;
79    let size = raw.len();
80
81    let match_opt = REVER.find(&raw);
82
83    let (fore, back) = match match_opt {
84        Some(m) if m.start() <= 12 => (m.start(), m.end()),
85        _ => {
86            return Err(KERIError::ValueError(format!(
87                "Invalid version string in raw = {:?}",
88                raw
89            )))
90        }
91    };
92
93    // Update version string with latest kind and size
94    let vs = versify("KERI", &vrsn, &kind.to_string(), size as u64)?;
95
96    // Find version string in raw
97    let fore = &raw[..fore];
98    let back = &raw[back..];
99    // Find version string in raw
100    // Replace old version string in raw with new one
101    let mut new_raw = Vec::with_capacity(fore.len() + vs.as_bytes().len() + back.len());
102    new_raw.extend_from_slice(fore);
103    new_raw.extend_from_slice(vs.as_bytes());
104    new_raw.extend_from_slice(back);
105
106    if size != new_raw.len() {
107        return Err(KERIError::ValueError(format!(
108            "Malformed version string size = {}",
109            vs
110        )));
111    }
112
113    // Update ked with new version string
114    ked_mut.insert("v".to_string(), SadValue::String(vs));
115
116    Ok((new_raw, proto, kind.to_string(), ked_mut, vrsn))
117}
118
119#[cfg(test)]
120mod tests {
121    use super::*;
122    use crate::keri::core::serdering::SadValue;
123    use crate::keri::KERIError;
124    use indexmap::IndexMap;
125
126    #[test]
127    fn test_sizeify() -> Result<(), KERIError> {
128        // Create a test KED with version string using Sadd (IndexMap<String, SadValue>)
129        let mut ked = IndexMap::new();
130
131        // Add required fields
132        ked.insert(
133            "v".to_string(),
134            SadValue::String("KERI10JSON000000_".to_string()),
135        );
136        ked.insert("t".to_string(), SadValue::String("icp".to_string()));
137        ked.insert(
138            "d".to_string(),
139            SadValue::String("E_0C8xxRQ8I7R5URH_SLED_YQFVpzw9_XYGg7p5YENGM".to_string()),
140        );
141        ked.insert(
142            "i".to_string(),
143            SadValue::String("E_0C8xxRQ8I7R5URH_SLED_YQFVpzw9_XYGg7p5YENGM".to_string()),
144        );
145        ked.insert("s".to_string(), SadValue::String("0".to_string()));
146        ked.insert("kt".to_string(), SadValue::String("1".to_string()));
147
148        // Add key list
149        ked.insert(
150            "k".to_string(),
151            SadValue::Array(vec![SadValue::String(
152                "DKvWXaxQfN91JgPjrguoCTXPGtZWJoV9kFEu8MMuxVSZ".to_string(),
153            )]),
154        );
155
156        // Add empty lists
157        ked.insert("nt".to_string(), SadValue::String("0".to_string()));
158        ked.insert("n".to_string(), SadValue::Array(vec![]));
159        ked.insert("bt".to_string(), SadValue::String("0".to_string()));
160        ked.insert("b".to_string(), SadValue::Array(vec![]));
161        ked.insert("c".to_string(), SadValue::Array(vec![]));
162        ked.insert("a".to_string(), SadValue::Array(vec![]));
163
164        // Call sizeify
165        let (raw, proto, kind, updated_ked, vrsn) = sizeify(&ked, None, None)?;
166
167        // Check results
168        assert_eq!(proto, "KERI");
169        assert_eq!(kind, "JSON");
170        assert_eq!(vrsn, Versionage { major: 1, minor: 0 });
171
172        // Check if size was updated in version string
173        if let SadValue::String(updated_v) = &updated_ked["v"] {
174            assert!(updated_v.starts_with("KERI10JSON"));
175            assert_ne!(updated_v, "KERI10JSON000000_"); // Should have actual size, not placeholder
176
177            // Size in version string should reflect raw length
178            let smellage = deversify(updated_v)?;
179            let actual_size = smellage.size;
180            assert_eq!(actual_size, raw.len());
181        } else {
182            panic!("Expected version to be a string value");
183        }
184
185        Ok(())
186    }
187
188    #[test]
189    fn test_sizeify_with_custom_kind() -> Result<(), KERIError> {
190        // Create a test KED with version string using Sadd
191        let mut ked = IndexMap::new();
192
193        // Add required fields
194        ked.insert(
195            "v".to_string(),
196            SadValue::String("KERI10JSON000000_".to_string()),
197        );
198        ked.insert("t".to_string(), SadValue::String("icp".to_string()));
199        ked.insert(
200            "d".to_string(),
201            SadValue::String("E_0C8xxRQ8I7R5URH_SLED_YQFVpzw9_XYGg7p5YENGM".to_string()),
202        );
203        ked.insert(
204            "i".to_string(),
205            SadValue::String("E_0C8xxRQ8I7R5URH_SLED_YQFVpzw9_XYGg7p5YENGM".to_string()),
206        );
207
208        // Call sizeify with CBOR kind
209        let (_, _, kind, updated_ked, _) = sizeify(&ked, Some(&Kinds::Cbor), None)?;
210
211        // Check if kind was set correctly
212        assert_eq!(kind, "CBOR");
213
214        // Version string should reflect CBOR kind
215        if let SadValue::String(updated_v) = &updated_ked["v"] {
216            assert!(updated_v.starts_with("KERI10CBOR"));
217        } else {
218            panic!("Expected version to be a string value");
219        }
220
221        Ok(())
222    }
223
224    #[test]
225    fn test_sizeify_unsupported_version() {
226        // Create a test KED with version string using Sadd
227        let mut ked = IndexMap::new();
228
229        // Add required fields
230        ked.insert(
231            "v".to_string(),
232            SadValue::String("KERI10JSON000000_".to_string()),
233        );
234        ked.insert("t".to_string(), SadValue::String("icp".to_string()));
235
236        // Call sizeify with unsupported version
237        let result = sizeify(&ked, None, Some(Versionage { major: 2, minor: 0 }));
238
239        // Should return an error
240        assert!(result.is_err());
241        if let Err(KERIError::ValueError(msg)) = result {
242            assert!(msg.contains("Unsupported version"));
243        } else {
244            panic!("Expected ValueError");
245        }
246    }
247}