1use crate::cesr::number::Number;
2use crate::cesr::tholder::{Tholder, TholderSith};
3use crate::cesr::Versionage;
4use crate::keri::core::eventing::{ample, MAX_INT_THOLD};
5use crate::keri::core::serdering::{SadValue, SerderKERI};
6use crate::keri::{versify, Ilks, KERIError};
7use indexmap::IndexMap;
8use num_bigint::BigUint;
9use serde_json::Value;
10use std::collections::HashSet;
11
12pub struct RotateEventBuilder {
13 pre: String,
14 keys: Vec<String>,
15 dig: String,
16
17 ilk: String,
18 sn: usize,
19 isith: Option<TholderSith>,
20 ndigs: Vec<String>,
21 nsith: Option<TholderSith>,
22 toad: Option<usize>,
23 wits: Vec<String>,
24 cuts: Vec<String>,
25 adds: Vec<String>,
26 data: Vec<SadValue>,
27 version: String,
28 kind: String,
29 intive: bool,
30}
31
32impl RotateEventBuilder {
33 pub fn new(pre: String, keys: Vec<String>, dig: String) -> Self {
34 Self {
35 pre,
36 keys,
37 dig,
38 ilk: Ilks::ROT.to_string(),
39 sn: 1,
40 isith: None,
41 ndigs: Vec::new(),
42 nsith: None,
43 toad: None,
44 wits: Vec::new(),
45 cuts: Vec::new(),
46 adds: Vec::new(),
47 data: Vec::new(),
48 version: "KERI10JSON000000_".to_string(),
49 kind: "JSON".to_string(),
50 intive: false,
51 }
52 }
53
54 pub fn with_ilk(mut self, ilk: String) -> Self {
55 self.ilk = ilk;
56 self
57 }
58
59 pub fn with_sn(mut self, sn: usize) -> Self {
60 self.sn = sn;
61 self
62 }
63
64 pub fn with_isith(mut self, isith: TholderSith) -> Self {
65 self.isith = Some(isith);
66 self
67 }
68
69 pub fn with_ndigs(mut self, ndigs: Vec<String>) -> Self {
70 self.ndigs = ndigs;
71 self
72 }
73
74 pub fn with_next_keys(mut self, ndigs: Vec<String>) -> Self {
75 self.ndigs = ndigs;
76 self
77 }
78
79 pub fn with_nsith(mut self, nsith: TholderSith) -> Self {
80 self.nsith = Some(nsith);
81 self
82 }
83
84 pub fn with_toad(mut self, toad: usize) -> Self {
85 self.toad = Some(toad);
86 self
87 }
88
89 pub fn with_wits(mut self, wits: Vec<String>) -> Self {
90 self.wits = wits;
91 self
92 }
93
94 pub fn with_cuts(mut self, cuts: Vec<String>) -> Self {
95 self.cuts = cuts;
96 self
97 }
98
99 pub fn with_adds(mut self, adds: Vec<String>) -> Self {
100 self.adds = adds;
101 self
102 }
103
104 pub fn with_data(mut self, data: Vec<SadValue>) -> Self {
105 self.data = data;
106 self
107 }
108
109 pub fn with_version(mut self, version: String) -> Self {
110 self.version = version;
111 self
112 }
113
114 pub fn with_kind(mut self, kind: String) -> Self {
115 self.kind = kind;
116 self
117 }
118
119 pub fn with_intive(mut self, intive: bool) -> Self {
120 self.intive = intive;
121 self
122 }
123
124 pub fn build(self) -> Result<SerderKERI, KERIError> {
125 if self.ilk != Ilks::ROT && self.ilk != Ilks::DRT {
127 return Err(KERIError::ValueError(format!(
128 "Invalid ilk = {} for rot or drt.",
129 self.ilk
130 )));
131 }
132
133 let sner = Number::from_num(&BigUint::from(self.sn))?;
135 if sner.num() < 1 {
136 return Err(KERIError::ValueError(format!(
137 "Invalid sn = 0x{} for rot or drt.",
138 sner.numh()
139 )));
140 }
141
142 let tholder = match self.isith {
144 Some(sith) => Tholder::new(None, None, Some(sith))?,
145 None => {
146 let default_isith =
147 std::cmp::max(1, (self.keys.len() as f64 / 2.0).ceil() as usize);
148 Tholder::new(None, None, Some(TholderSith::Integer(default_isith)))?
149 }
150 };
151
152 if let Some(num) = tholder.num() {
154 if num < 1 {
155 return Err(KERIError::ValueError(format!(
156 "Invalid sith = {} less than 1.",
157 num
158 )));
159 }
160 }
161 if tholder.size() > self.keys.len() {
162 return Err(KERIError::ValueError(format!(
163 "Invalid sith = {:?} for keys = {:?}",
164 tholder.sith(),
165 self.keys
166 )));
167 }
168
169 let ntholder = match self.nsith {
171 Some(sith) => Tholder::new(None, None, Some(sith))?,
172 None => {
173 let default_nsith =
174 std::cmp::max(0, (self.ndigs.len() as f64 / 2.0).ceil() as usize);
175 Tholder::new(None, None, Some(TholderSith::Integer(default_nsith)))?
176 }
177 };
178
179 if ntholder.size() > self.ndigs.len() {
181 return Err(KERIError::ValueError(format!(
182 "Invalid nsith = {:?} for ndigs = {:?}",
183 ntholder.sith(),
184 self.ndigs
185 )));
186 }
187
188 let wits = self.wits;
190 let witset: HashSet<_> = wits.iter().collect();
191 if witset.len() != wits.len() {
192 return Err(KERIError::ValueError(format!(
193 "Invalid wits = {:?}, has duplicates.",
194 wits
195 )));
196 }
197
198 let cuts = self.cuts;
200 let cutset: HashSet<_> = cuts.iter().collect();
201 if cutset.len() != cuts.len() {
202 return Err(KERIError::ValueError(format!(
203 "Invalid cuts = {:?}, has duplicates.",
204 cuts
205 )));
206 }
207
208 for cut in &cuts {
210 if !wits.contains(cut) {
211 return Err(KERIError::ValueError(format!(
212 "Invalid cuts = {:?}, not all members in wits.",
213 cuts
214 )));
215 }
216 }
217
218 let adds = self.adds;
220 let addset: HashSet<_> = adds.iter().collect();
221 if addset.len() != adds.len() {
222 return Err(KERIError::ValueError(format!(
223 "Invalid adds = {:?}, has duplicates.",
224 adds
225 )));
226 }
227
228 for add in &adds {
230 if wits.contains(add) {
231 return Err(KERIError::ValueError(format!(
232 "Intersecting wits = {:?} and adds = {:?}.",
233 wits, adds
234 )));
235 }
236 }
237
238 for add in &adds {
240 if cuts.contains(add) {
241 return Err(KERIError::ValueError(format!(
242 "Intersecting cuts = {:?} and adds = {:?}.",
243 cuts, adds
244 )));
245 }
246 }
247
248 let newitset: HashSet<String> = wits
250 .iter()
251 .filter(|wit| !cuts.contains(wit))
252 .cloned()
253 .chain(adds.clone())
254 .collect();
255
256 if newitset.len() != (wits.len() - cuts.len() + adds.len()) {
257 return Err(KERIError::ValueError(format!(
258 "Invalid member combination among wits = {:?}, cuts = {:?}, and adds = {:?}.",
259 wits, cuts, adds
260 )));
261 }
262
263 let toader = if let Some(toad) = self.toad {
265 Number::from_num(&BigUint::from(toad))?
266 } else if newitset.is_empty() {
267 Number::from_num(&BigUint::from(0usize))?
268 } else {
269 Number::from_num(&BigUint::from(ample(newitset.len())))?
271 };
272
273 if !newitset.is_empty() {
275 if toader.num() < 1 || toader.num() as usize > newitset.len() {
276 return Err(KERIError::ValueError(format!(
277 "Invalid toad = {} for wits = {:?}",
278 toader.num(),
279 newitset
280 )));
281 }
282 } else if toader.num() != 0 {
283 return Err(KERIError::ValueError(format!(
284 "Invalid toad = {} for wits = {:?}",
285 toader.num(),
286 newitset
287 )));
288 }
289
290 let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
292
293 let mut ked = IndexMap::new();
295 ked.insert("v".to_string(), SadValue::String(vs));
296 ked.insert("t".to_string(), SadValue::String(self.ilk));
297 ked.insert("d".to_string(), SadValue::String("".to_string()));
298 ked.insert("i".to_string(), SadValue::String(self.pre));
299 ked.insert("s".to_string(), SadValue::String(sner.numh()));
300 ked.insert("p".to_string(), SadValue::String(self.dig));
301
302 let kt =
304 if self.intive && tholder.num().is_some() && tholder.num().unwrap() <= MAX_INT_THOLD {
305 Value::Number(serde_json::Number::from(tholder.num().unwrap() as u64))
306 } else {
307 match &tholder.sith() {
308 TholderSith::Integer(n) => Value::Number(serde_json::Number::from(*n as u64)),
309 TholderSith::HexString(s) => Value::String(s.clone()),
310 TholderSith::Json(s) => serde_json::from_str(s).map_err(|e| {
311 KERIError::ValueError(format!(
312 "Invalid tholder = {} for keys = {:?}",
313 s, self.keys
314 ))
315 })?,
316 TholderSith::Weights(w) => serde_json::to_value(w).map_err(|e| {
317 KERIError::ValueError(format!(
318 "Invalid tholder = {:?} for keys = {:?}",
319 w, self.keys
320 ))
321 })?,
322 }
323 };
324
325 match kt {
326 Value::Number(n) => {
327 if let Some(_) = n.as_u64() {
328 ked.insert("kt".to_string(), SadValue::Number(n));
329 }
330 }
331 Value::String(s) => {
332 ked.insert("kt".to_string(), SadValue::String(s.to_string()));
333 ()
334 }
335 _ => {
336 if let Some(num) = tholder.num() {
337 ked.insert("kt".to_string(), SadValue::String(num.to_string()));
338 } else {
339 ked.insert("kt".to_string(), super::weights_value(&kt)?);
341 }
342 }
343 };
344
345 let key_values = self
347 .keys
348 .iter()
349 .map(|k| SadValue::String(k.clone()))
350 .collect();
351 ked.insert("k".to_string(), SadValue::Array(key_values)); let nt = if self.intive
355 && ntholder.num().is_some()
356 && ntholder.num().unwrap() <= MAX_INT_THOLD
357 {
358 Value::Number(serde_json::Number::from(ntholder.num().unwrap() as u64))
359 } else {
360 match &ntholder.sith() {
361 TholderSith::Integer(n) => Value::Number(serde_json::Number::from(*n as u64)),
362 TholderSith::HexString(s) => Value::String(s.clone()),
363 TholderSith::Json(s) => serde_json::from_str(s).map_err(|e| {
364 KERIError::ValueError(format!(
365 "Invalid tholder = {} for keys = {:?}",
366 s, self.keys
367 ))
368 })?,
369 TholderSith::Weights(w) => serde_json::to_value(w).map_err(|e| {
370 KERIError::ValueError(format!(
371 "Invalid tholder = {:?} for keys = {:?}",
372 w, self.keys
373 ))
374 })?,
375 }
376 };
377
378 match nt {
379 Value::Number(n) => {
380 if let Some(_) = n.as_u64() {
381 ked.insert("nt".to_string(), SadValue::Number(n));
382 }
383 }
384 Value::String(s) => {
385 ked.insert("nt".to_string(), SadValue::String(s.to_string()));
386 ()
387 }
388 _ => {
389 if let Some(num) = ntholder.num() {
390 ked.insert("nt".to_string(), SadValue::String(num.to_string()));
391 } else {
392 ked.insert("nt".to_string(), super::weights_value(&nt)?);
393 }
394 }
395 };
396
397 let ndig_values = self
399 .ndigs
400 .iter()
401 .map(|n| SadValue::String(n.clone()))
402 .collect();
403 ked.insert("n".to_string(), SadValue::Array(ndig_values)); let bt = if self.intive && toader.num() <= MAX_INT_THOLD as u128 {
408 Value::Number(serde_json::Number::from(toader.num() as u64))
409 } else {
410 Value::String(toader.numh().to_string())
411 };
412 match bt {
413 Value::Number(n) => {
414 if let Some(_) = n.as_u64() {
415 ked.insert("bt".to_string(), SadValue::Number(n));
416 }
417 }
418 Value::String(s) => {
419 ked.insert("bt".to_string(), SadValue::String(s));
420 ()
421 }
422 _ => {
423 ked.insert(
424 "bt".to_string(),
425 SadValue::String(toader.numh().to_string()),
426 );
427 ()
428 }
429 };
430
431 let cut_values = cuts.iter().map(|n| SadValue::String(n.clone())).collect();
433 ked.insert("br".to_string(), SadValue::Array(cut_values)); let add_values = adds.iter().map(|n| SadValue::String(n.clone())).collect();
437 ked.insert("ba".to_string(), SadValue::Array(add_values)); if !self.data.is_empty() {
441 ked.insert("a".to_string(), SadValue::Array(self.data.clone())); }
443
444 let serder = SerderKERI::from_sad_and_saids(&ked, None)?;
446 Ok(serder)
447 }
448}
449
450#[cfg(test)]
451mod tests {
452 use super::*;
453 use crate::cesr::diger::Diger;
454 use crate::cesr::mtr_dex;
455 use crate::cesr::signing::signer::Signer;
456 use crate::Matter;
457 use std::error::Error;
458
459 #[test]
460 fn test_rotation_event_builder_basic() -> Result<(), Box<dyn Error>> {
461 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
463 let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
464 let keys = vec!["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string()];
465
466 let serder = RotateEventBuilder::new(pre.clone(), keys, dig.clone()).build()?;
467
468 let ked = serder.ked();
470
471 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ROT);
473
474 assert_eq!(ked["i"].as_str().unwrap(), pre);
476 assert_eq!(ked["p"].as_str().unwrap(), dig);
477 assert_eq!(ked["s"].as_str().unwrap(), "1");
478
479 Ok(())
480 }
481
482 #[test]
483 fn test_rotation_event_builder_with_witnesses() -> Result<(), Box<dyn Error>> {
484 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
486 let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
487 let keys = vec!["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string()];
488
489 let wits = vec![
491 "BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha".to_string(),
492 "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string(),
493 "BIKKuvBwpmDVA4Ds-EpL5bt9OqPzWPja2LigFYZN2YfX".to_string(),
494 ];
495
496 let cuts = vec!["BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string()];
498
499 let adds = vec!["BMusuVxC3AuXkqXAD-2UN4PWr2Eu_7oX3UXxrtXASh-0".to_string()];
501
502 let serder = RotateEventBuilder::new(pre.clone(), keys, dig.clone())
503 .with_wits(wits)
504 .with_cuts(cuts)
505 .with_adds(adds)
506 .with_toad(2)
507 .build()?;
508
509 let ked = serder.ked();
511
512 assert_eq!(ked["bt"].as_str().unwrap(), "2");
514
515 let br = ked["br"].as_array().unwrap();
517 assert_eq!(br.len(), 1);
518 assert_eq!(
519 br[0].as_str().unwrap(),
520 "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM"
521 );
522
523 let ba = ked["ba"].as_array().unwrap();
525 assert_eq!(ba.len(), 1);
526 assert_eq!(
527 ba[0].as_str().unwrap(),
528 "BMusuVxC3AuXkqXAD-2UN4PWr2Eu_7oX3UXxrtXASh-0"
529 );
530
531 Ok(())
532 }
533
534 #[test]
535 fn test_rotation_event_builder_with_next_keys() -> Result<(), Box<dyn Error>> {
536 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
538 let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
539 let keys = vec!["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string()];
540
541 let seed = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
543 \x98Y\xdd\xe8";
544 let signer = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
545 let ndigs = vec![Diger::new(
546 Some(&signer.verfer().qb64b()),
547 Some(mtr_dex::BLAKE3_256),
548 None,
549 None,
550 )?
551 .qb64()];
552
553 let serder = RotateEventBuilder::new(pre.clone(), keys, dig.clone())
554 .with_next_keys(ndigs.clone())
555 .with_sn(2)
556 .build()?;
557
558 let ked = serder.ked();
560
561 assert_eq!(ked["s"].as_str().unwrap(), "2");
563
564 let n = ked["n"].as_array().unwrap();
566 assert_eq!(n.len(), 1);
567 assert_eq!(n[0].as_str().unwrap(), ndigs[0]);
568
569 Ok(())
570 }
571
572 #[test]
573 fn test_rotation_event_builder_with_intive() -> Result<(), Box<dyn Error>> {
574 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
576 let dig = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
577 let keys = vec!["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string()];
578
579 let seed = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
581 \x98Y\xdd\xe8";
582 let signer = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
583 let ndigs = vec![Diger::new(
584 Some(&signer.verfer().qb64b()),
585 Some(mtr_dex::BLAKE3_256),
586 None,
587 None,
588 )?
589 .qb64()];
590
591 let serder = RotateEventBuilder::new(pre.clone(), keys, dig.clone())
592 .with_next_keys(ndigs)
593 .with_intive(true)
594 .build()?;
595
596 let ked = serder.ked();
598
599 assert!(ked["kt"].is_number());
601 assert_eq!(ked["kt"].as_u64().unwrap(), 1);
602
603 assert!(ked["nt"].is_number());
604 assert_eq!(ked["nt"].as_u64().unwrap(), 1);
605
606 assert!(ked["bt"].is_number());
607 assert_eq!(ked["bt"].as_u64().unwrap(), 0);
608
609 Ok(())
610 }
611
612 #[test]
613 fn test_rotation_transferable_not_abandoned() -> Result<(), Box<dyn Error>> {
614 let seed0 = b"\x9f\x82\xad\xf4\xa9\xff\xda\xbc\xed\x39\xb6\xc8\x29\xcb\x6a\xb0\x08\x85\x5a\xcb\xc4\x19\x39\xbb\x74\xdc\x70\x8a\x38\xb6\x3c\x99";
616 let signer0 = Signer::new(Some(&seed0[..]), Some(mtr_dex::ED25519_SEED), Some(true))?;
617 assert_eq!(signer0.code(), mtr_dex::ED25519_SEED);
618 assert_eq!(signer0.verfer().code(), mtr_dex::ED25519);
619
620 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
621 let keys1 = vec!["DB4GWvru73jWZKpNgMQp8ayDRin0NG0Ymn_RXQP_v-PQ".to_string()];
622
623 let seed2 = b"\xbe\x96\x02\xa9\x88\xce\xf9O\x1e\x0fo\xc0\xff\x98\xb6\xfa\x1e\xa2y\xf2e\xf9AL\x1aeK\xafj\xa1pB";
626 let signer2 = Signer::new(Some(&seed2[..]), Some(mtr_dex::ED25519_SEED), Some(true))?;
627 assert_eq!(signer2.code(), mtr_dex::ED25519_SEED);
628 assert_eq!(signer2.verfer().code(), mtr_dex::ED25519);
629
630 let keys2 = vec![Diger::new(
632 Some(&signer2.verfer().qb64b()),
633 Some(mtr_dex::BLAKE3_256),
634 None,
635 None,
636 )?
637 .qb64()];
638
639 let said = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
640 let serder1 = RotateEventBuilder::new(pre.clone(), keys1.clone(), said.clone())
642 .with_ndigs(keys2.clone())
643 .with_sn(1)
644 .build()?;
645
646 let ked = serder1.ked();
648 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ROT);
649 assert_eq!(ked["i"].as_str().unwrap(), pre);
650 assert_eq!(ked["s"].as_str().unwrap(), "1");
651 assert_eq!(ked["p"].as_str().unwrap(), said);
652 assert_eq!(ked["kt"].as_str().unwrap(), "1");
653 assert_eq!(ked["nt"].as_str().unwrap(), "1");
654
655 let n = ked["n"].as_array().unwrap();
656 assert_eq!(n.len(), 1);
657 assert_eq!(n[0].as_str().unwrap(), keys2[0]);
658
659 assert_eq!(ked["bt"].as_str().unwrap(), "0");
660
661 let expected_raw = b"{\"v\":\"KERI10JSON000160_\",\"t\":\"rot\",\"d\":\"EFl8nvRCbN2xQJI75nBXp-gaXuHJw8zheVjw\
663 MN_rB-pb\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"1\",\"p\":\"EJ\
664 QUyxnzIAtmZPoq9f4fExeGN0qfJmaFnUEKTwIiTBPj\",\"kt\":\"1\",\"k\":[\"DB4GWvru73jWZKpNg\
665 MQp8ayDRin0NG0Ymn_RXQP_v-PQ\"],\"nt\":\"1\",\"n\":[\"EIsKL3B6Zz5ICGxCQp-SoLXjwOrdlSb\
666 LJrEn21c2zVaU\"],\"bt\":\"0\",\"br\":[],\"ba\":[],\"a\":[]}";
667
668 assert_eq!(ked["v"].as_str().unwrap(), "KERI10JSON000160_");
671 assert_eq!(ked["t"].as_str().unwrap(), "rot");
672
673 Ok(())
674 }
675
676 #[test]
677 fn test_rotation_transferable_not_abandoned_intive() -> Result<(), Box<dyn Error>> {
678 let seed0 = b"\x9f\x82\xad\xf4\xa9\xff\xda\xbc\xed\x39\xb6\xc8\x29\xcb\x6a\xb0\x08\x85\x5a\xcb\xc4\x19\x39\xbb\x74\xdc\x70\x8a\x38\xb6\x3c\x99";
680 let signer0 = Signer::new(Some(&seed0[..]), Some(mtr_dex::ED25519_SEED), Some(true))?;
681 assert_eq!(signer0.code(), mtr_dex::ED25519_SEED);
682 assert_eq!(signer0.verfer().code(), mtr_dex::ED25519);
683
684 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
685 let keys1 = vec!["DB4GWvru73jWZKpNgMQp8ayDRin0NG0Ymn_RXQP_v-PQ".to_string()];
686
687 let seed2 = b"\xbe\x96\x02\xa9\x88\xce\xf9O\x1e\x0fo\xc0\xff\x98\xb6\xfa\x1e\xa2y\xf2e\xf9AL\x1aeK\xafj\xa1pB";
691 let signer2 = Signer::new(Some(&seed2[..]), Some(mtr_dex::ED25519_SEED), Some(true))?;
692 assert_eq!(signer2.code(), mtr_dex::ED25519_SEED);
693 assert_eq!(signer2.verfer().code(), mtr_dex::ED25519);
694
695 let keys2 = vec![Diger::new(
697 Some(&signer2.verfer().qb64b()),
698 Some(mtr_dex::BLAKE3_256),
699 None,
700 None,
701 )?
702 .qb64()];
703
704 let said = "EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string();
706 let serder1 = RotateEventBuilder::new(pre.clone(), keys1.clone(), said.clone())
707 .with_ndigs(keys2.clone())
708 .with_sn(1)
709 .with_intive(true)
710 .build()?;
711
712 let ked = serder1.ked();
714 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ROT);
715 assert_eq!(ked["i"].as_str().unwrap(), pre);
716 assert_eq!(ked["s"].as_str().unwrap(), "1");
717 assert_eq!(ked["p"].as_str().unwrap(), said);
718
719 assert!(ked["kt"].is_number());
721 assert_eq!(ked["kt"].as_u64().unwrap(), 1);
722
723 assert!(ked["nt"].is_number());
724 assert_eq!(ked["nt"].as_u64().unwrap(), 1);
725
726 let n = ked["n"].as_array().unwrap();
727 assert_eq!(n.len(), 1);
728 assert_eq!(n[0].as_str().unwrap(), keys2[0]);
729
730 assert!(ked["bt"].is_number());
731 assert_eq!(ked["bt"].as_u64().unwrap(), 0);
732
733 let expected_raw = b"{\"v\":\"KERI10JSON00015a_\",\"t\":\"rot\",\"d\":\"ECauhEzA4DJDXVDnNQiGQ0sKXa6sx_GgS8Eb\
735 dzm4E-kQ\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"1\",\"p\":\"EJ\
736 QUyxnzIAtmZPoq9f4fExeGN0qfJmaFnUEKTwIiTBPj\",\"kt\":1,\"k\":[\"DB4GWvru73jWZKpNgMQ\
737 p8ayDRin0NG0Ymn_RXQP_v-PQ\"],\"nt\":1,\"n\":[\"EIsKL3B6Zz5ICGxCQp-SoLXjwOrdlSbLJrE\
738 n21c2zVaU\"],\"bt\":0,\"br\":[],\"ba\":[],\"a\":[]}";
739
740 assert_eq!(ked["v"].as_str().unwrap(), "KERI10JSON00015a_");
742 assert_eq!(ked["t"].as_str().unwrap(), "rot");
743
744 Ok(())
745 }
746
747 #[test]
748 fn test_rotation_with_witnesses() -> Result<(), Box<dyn Error>> {
749 let pre = "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH".to_string();
751 let keys1 = vec!["DB4GWvru73jWZKpNgMQp8ayDRin0NG0Ymn_RXQP_v-PQ".to_string()];
752 let dig = "EJQUyxnzIAtmZPoq9f4fExeGN0qfJmaFnUEKTwIiTBPj".to_string();
753
754 let wits = vec![
756 "BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha".to_string(),
757 "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string(),
758 "BIKKuvBwpmDVA4Ds-EpL5bt9OqPzWPja2LigFYZN2YfX".to_string(),
759 ];
760
761 let cuts = vec!["BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string()];
763
764 let adds = vec!["BMusuVxC3AuXkqXAD-2UN4PWr2Eu_7oX3UXxrtXASh-0".to_string()];
766
767 let seed2 = b"\xbe\x96\x02\xa9\x88\xce\xf9O\x1e\x0fo\xc0\xff\x98\xb6\xfa\x1e\xa2y\xf2e\xf9AL\x1aeK\xafj\xa1pB";
769 let signer2 = Signer::new(Some(&seed2[..]), Some(mtr_dex::ED25519_SEED), Some(true))?;
770 let keys2 = vec![Diger::new(
771 Some(&signer2.verfer().qb64b()),
772 Some(mtr_dex::BLAKE3_256),
773 None,
774 None,
775 )?
776 .qb64()];
777
778 let serder = RotateEventBuilder::new(pre.clone(), keys1.clone(), dig.clone())
780 .with_ndigs(keys2)
781 .with_wits(wits)
782 .with_cuts(cuts)
783 .with_adds(adds)
784 .with_toad(2)
785 .build()?;
786
787 let ked = serder.ked();
789 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ROT);
790 assert_eq!(ked["i"].as_str().unwrap(), pre);
791 assert_eq!(ked["p"].as_str().unwrap(), dig);
792
793 assert_eq!(ked["bt"].as_str().unwrap(), "2");
795
796 let br = ked["br"].as_array().unwrap();
798 assert_eq!(br.len(), 1);
799 assert_eq!(
800 br[0].as_str().unwrap(),
801 "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM"
802 );
803
804 let ba = ked["ba"].as_array().unwrap();
806 assert_eq!(ba.len(), 1);
807 assert_eq!(
808 ba[0].as_str().unwrap(),
809 "BMusuVxC3AuXkqXAD-2UN4PWr2Eu_7oX3UXxrtXASh-0"
810 );
811
812 Ok(())
813 }
814}