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
17static 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
22pub 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 let version = version_opt.unwrap_or_else(|| Versionage { major: 1, minor: 0 });
47
48 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 let smellage = deversify(ked["v"].as_str().unwrap())?;
58 let (proto, vrsn, knd) = (smellage.proto, smellage.vrsn, smellage.kind);
59
60 if vrsn != version {
62 return Err(KERIError::ValueError(format!(
63 "Unsupported version = {}.{}",
64 vrsn.major, vrsn.minor
65 )));
66 }
67
68 let kind = match kind_opt {
70 Some(k) => k,
71 None => &Kinds::from(&knd)?,
72 };
73
74 let mut ked_mut = ked.clone();
76
77 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 let vs = versify("KERI", &vrsn, &kind.to_string(), size as u64)?;
95
96 let fore = &raw[..fore];
98 let back = &raw[back..];
99 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 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 let mut ked = IndexMap::new();
130
131 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 ked.insert(
150 "k".to_string(),
151 SadValue::Array(vec![SadValue::String(
152 "DKvWXaxQfN91JgPjrguoCTXPGtZWJoV9kFEu8MMuxVSZ".to_string(),
153 )]),
154 );
155
156 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 let (raw, proto, kind, updated_ked, vrsn) = sizeify(&ked, None, None)?;
166
167 assert_eq!(proto, "KERI");
169 assert_eq!(kind, "JSON");
170 assert_eq!(vrsn, Versionage { major: 1, minor: 0 });
171
172 if let SadValue::String(updated_v) = &updated_ked["v"] {
174 assert!(updated_v.starts_with("KERI10JSON"));
175 assert_ne!(updated_v, "KERI10JSON000000_"); 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 let mut ked = IndexMap::new();
192
193 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 let (_, _, kind, updated_ked, _) = sizeify(&ked, Some(&Kinds::Cbor), None)?;
210
211 assert_eq!(kind, "CBOR");
213
214 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 let mut ked = IndexMap::new();
228
229 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 let result = sizeify(&ked, None, Some(Versionage { major: 2, minor: 0 }));
238
239 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}