1use crate::cesr::number::Number;
2use crate::cesr::tholder::{Tholder, TholderSith};
3use crate::cesr::Versionage;
4use crate::keri::core::eventing::{ample, is_digest_code, is_prefix_code, MAX_INT_THOLD};
5use crate::keri::core::serdering::{SadValue, Sadder, SerderKERI};
6use crate::keri::{versify, KERIError};
7use num_bigint::BigUint;
8use serde_json::Value;
9use std::collections::{HashMap, HashSet};
10
11pub struct InceptionEventBuilder {
13 keys: Vec<String>,
15
16 isith: Option<TholderSith>,
18 ndigs: Vec<String>,
19 nsith: Option<TholderSith>,
20 toad: Option<usize>,
21 wits: Vec<String>,
22 cnfg: Vec<String>,
23 data: Vec<SadValue>,
24 version: String,
25 kind: String,
26 code: Option<String>,
27 intive: bool,
28 delpre: Option<String>,
29}
30
31impl InceptionEventBuilder {
32 pub fn new(keys: Vec<String>) -> Self {
34 InceptionEventBuilder {
35 keys,
36 isith: None,
37 ndigs: Vec::new(),
38 nsith: None,
39 toad: None,
40 wits: Vec::new(),
41 cnfg: Vec::new(),
42 data: Vec::new(),
43 version: "KERI10JSON000000_".to_string(), kind: "JSON".to_string(), code: None,
46 intive: false,
47 delpre: None,
48 }
49 }
50
51 pub fn with_isith(mut self, isith: TholderSith) -> Self {
53 self.isith = Some(isith);
54 self
55 }
56
57 pub fn with_ndigs(mut self, ndigs: Vec<String>) -> Self {
59 self.ndigs = ndigs;
60 self
61 }
62
63 pub fn with_nsith(mut self, nsith: TholderSith) -> Self {
65 self.nsith = Some(nsith);
66 self
67 }
68
69 pub fn with_toad(mut self, toad: usize) -> Self {
71 self.toad = Some(toad);
72 self
73 }
74
75 pub fn with_wits(mut self, wits: Vec<String>) -> Self {
77 self.wits = wits;
78 self
79 }
80
81 pub fn with_cnfg(mut self, cnfg: Vec<String>) -> Self {
83 self.cnfg = cnfg;
84 self
85 }
86
87 pub fn with_data(mut self, data: Vec<SadValue>) -> Self {
89 self.data = data;
90 self
91 }
92
93 pub fn with_version(mut self, version: String) -> Self {
95 self.version = version;
96 self
97 }
98
99 pub fn with_kind(mut self, kind: String) -> Self {
101 self.kind = kind;
102 self
103 }
104
105 pub fn with_code(mut self, code: String) -> Self {
107 self.code = Some(code);
108 self
109 }
110
111 pub fn with_intive(mut self, intive: bool) -> Self {
113 self.intive = intive;
114 self
115 }
116
117 pub fn with_delpre(mut self, delpre: String) -> Self {
119 self.delpre = Some(delpre);
120 self
121 }
122
123 pub fn build(self) -> Result<SerderKERI, KERIError> {
125 let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
127
128 let ilk = if self.delpre.is_none() { "icp" } else { "dip" };
130
131 let sner = Number::from_num(&BigUint::from(0u32))?;
133
134 let isith = match self.isith {
136 Some(sith) => sith,
137 None => {
138 let default_threshold =
140 std::cmp::max(1, (self.keys.len() as f64 / 2.0).ceil() as usize);
141 TholderSith::Integer(default_threshold)
142 }
143 };
144
145 let tholder = Tholder::new(None, None, Some(isith.clone()))?;
147 if let Some(num) = tholder.num() {
148 if num < 1 {
149 return Err(KERIError::ValueError(format!(
150 "Invalid sith = {} less than 1.",
151 num
152 )));
153 }
154 }
155 if tholder.size() > self.keys.len() {
156 return Err(KERIError::ValueError(format!(
157 "Invalid sith = {:?} for keys = {:?}",
158 isith, self.keys
159 )));
160 }
161
162 let nsith = match self.nsith {
164 Some(sith) => sith,
165 None => {
166 let default_threshold =
168 std::cmp::max(0, (self.ndigs.len() as f64 / 2.0).ceil() as usize);
169 TholderSith::Integer(default_threshold)
170 }
171 };
172
173 let ntholder = Tholder::new(None, None, Some(nsith.clone()))?;
175 if ntholder.size() > self.ndigs.len() {
176 return Err(KERIError::ValueError(format!(
177 "Invalid nsith = {:?} for ndigs = {:?}",
178 nsith, self.ndigs
179 )));
180 }
181
182 let wits = self.wits;
184
185 let wits_set: HashSet<_> = wits.iter().cloned().collect();
187 if wits_set.len() != wits.len() {
188 return Err(KERIError::ValueError(format!(
189 "Invalid wits = {:?}, has duplicates.",
190 wits
191 )));
192 }
193
194 let toad = match self.toad {
196 Some(t) => t,
197 None => {
198 if wits.is_empty() {
199 0
200 } else {
201 ample(wits.len())
203 }
204 }
205 };
206
207 let toader = Number::from_num(&BigUint::from(toad))?;
209
210 if !wits.is_empty() {
212 if toader.num() < 1 || toader.num() > wits.len() as u128 {
213 return Err(KERIError::ValueError(format!(
214 "Invalid toad = {} for wits = {:?}",
215 toader.num(),
216 wits
217 )));
218 }
219 } else if toader.num() != 0 {
220 return Err(KERIError::ValueError(format!(
221 "Invalid toad = {} for wits = {:?}",
222 toader.num(),
223 wits
224 )));
225 }
226
227 let kt =
228 if self.intive && tholder.num().is_some() && tholder.num().unwrap() <= MAX_INT_THOLD {
229 Value::Number(serde_json::Number::from(tholder.num().unwrap() as u64))
230 } else {
231 match &tholder.sith() {
232 TholderSith::Integer(n) => Value::Number(serde_json::Number::from(*n as u64)),
233 TholderSith::HexString(s) => Value::String(s.clone()),
234 TholderSith::Json(s) => serde_json::from_str(s).map_err(|e| {
235 KERIError::ValueError(format!(
236 "Invalid tholder = {} for keys = {:?}",
237 s, self.keys
238 ))
239 })?,
240 TholderSith::Weights(w) => serde_json::to_value(w).map_err(|e| {
241 KERIError::ValueError(format!(
242 "Invalid tholder = {:?} for keys = {:?}",
243 w, self.keys
244 ))
245 })?,
246 }
247 };
248
249 let nt = if self.intive
250 && ntholder.num().is_some()
251 && ntholder.num().unwrap() <= MAX_INT_THOLD
252 {
253 Value::Number(serde_json::Number::from(ntholder.num().unwrap() as u64))
254 } else {
255 match &ntholder.sith() {
256 TholderSith::Integer(n) => Value::Number(serde_json::Number::from(*n as u64)),
257 TholderSith::HexString(s) => Value::String(s.clone()),
258 TholderSith::Json(s) => serde_json::from_str(s).map_err(|e| {
259 KERIError::ValueError(format!(
260 "Invalid ntholder = {} for keys = {:?}",
261 s, self.keys
262 ))
263 })?,
264 TholderSith::Weights(w) => serde_json::to_value(w).map_err(|e| {
265 KERIError::ValueError(format!(
266 "Invalid ntholder = {:?} for keys = {:?}",
267 w, self.keys
268 ))
269 })?,
270 }
271 };
272
273 let bt = if self.intive && toader.num() <= MAX_INT_THOLD as u128 {
274 Value::Number(serde_json::Number::from(toader.num() as u64))
275 } else {
276 Value::String(toader.numh().to_string())
277 };
278
279 let mut ked = Sadder::default();
281
282 ked.insert("v".to_string(), SadValue::String(vs));
284 ked.insert("t".to_string(), SadValue::String(ilk.to_string()));
285 ked.insert("d".to_string(), SadValue::String(String::new())); ked.insert("i".to_string(), SadValue::String(String::new())); ked.insert("s".to_string(), SadValue::String(sner.numh())); match kt {
290 Value::Number(n) => {
291 if let Some(n_u64) = n.as_u64() {
292 ked.insert("kt".to_string(), SadValue::Number(n));
293 }
294 }
295 Value::String(s) => {
296 ked.insert("kt".to_string(), SadValue::String(s.to_string()));
297 ()
298 }
299 _ => {
300 if let Some(num) = tholder.num() {
301 ked.insert("kt".to_string(), SadValue::String(num.to_string()));
302 } else {
303 ked.insert("kt".to_string(), super::weights_value(&kt)?);
305 }
306 }
307 };
308
309 let key_values = self
311 .keys
312 .iter()
313 .map(|k| SadValue::String(k.clone()))
314 .collect();
315 ked.insert("k".to_string(), SadValue::Array(key_values)); match nt {
319 Value::Number(n) => {
320 if let Some(n_u64) = n.as_u64() {
321 ked.insert("nt".to_string(), SadValue::Number(n));
322 }
323 }
324 Value::String(s) => {
325 ked.insert("nt".to_string(), SadValue::String(s));
326 ()
327 }
328 _ => {
329 if let Some(num) = ntholder.num() {
330 ked.insert("nt".to_string(), SadValue::String(num.to_string()));
331 } else {
332 ked.insert("nt".to_string(), super::weights_value(&nt)?);
333 }
334 }
335 };
336
337 let ndig_values = self
339 .ndigs
340 .iter()
341 .map(|n| SadValue::String(n.clone()))
342 .collect();
343 ked.insert("n".to_string(), SadValue::Array(ndig_values)); match bt {
347 Value::Number(n) => {
348 if let Some(n_u64) = n.as_u64() {
349 ked.insert("bt".to_string(), SadValue::Number(n));
350 }
351 }
352 Value::String(s) => {
353 ked.insert("bt".to_string(), SadValue::String(s));
354 ()
355 }
356 _ => {
357 ked.insert(
358 "bt".to_string(),
359 SadValue::String(toader.numh().to_string()),
360 );
361 ()
362 }
363 };
364
365 let wit_values = wits.iter().map(|w| SadValue::String(w.clone())).collect();
367 ked.insert("b".to_string(), SadValue::Array(wit_values)); let cnfg_values = self
371 .cnfg
372 .iter()
373 .map(|c| SadValue::String(c.clone()))
374 .collect();
375 ked.insert("c".to_string(), SadValue::Array(cnfg_values)); if !self.data.is_empty() {
379 ked.insert("a".to_string(), SadValue::Array(self.data.clone())); }
381
382 if let Some(delpre) = self.delpre.clone() {
384 ked.insert("di".to_string(), SadValue::String(delpre.clone()));
385 } else {
386 if (self.code.is_none() || !is_digest_code(&self.code.as_ref().unwrap()))
388 && self.keys.len() == 1
389 {
390 ked.insert("i".to_string(), SadValue::String(self.keys[0].clone()));
392 }
393 }
394
395 let mut saids_map = None;
397 if let Some(ref code) = self.code {
398 if is_prefix_code(code) {
399 let mut map = HashMap::new();
400 map.insert("i", code.clone());
401 saids_map = Some(map);
402 }
403 }
404
405 let mut saids = HashMap::new();
407 if let Some(ref code) = self.code {
409 if is_prefix_code(code) {
410 saids.insert("i", code.to_string());
411 }
412 }
413
414 let serder = SerderKERI::from_sad_and_saids(&ked, Some(saids))?;
416 Ok(serder)
417 }
418}
419
420#[cfg(test)]
421mod tests {
422 use super::*;
423 use crate::cesr::diger::Diger;
424 use crate::cesr::mtr_dex;
425 use crate::cesr::signing::Signer;
426 use crate::cesr::tholder::TholderSith;
427 use crate::keri::core::serdering::Serder;
428 use crate::keri::Ilks;
429 use crate::Matter;
430 use std::error::Error;
431
432 #[test]
433 fn test_inception_event_builder_non_transferable() -> Result<(), KERIError> {
434 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
436 \xc9\xbd\x04\x9d\x85)~\x93";
437
438 let signer0 = Signer::new(Some(&seed[..]), Some(mtr_dex::ED25519_SEED), Some(false))?;
440 assert_eq!(signer0.code(), mtr_dex::ED25519_SEED);
441 assert_eq!(signer0.verfer().code(), mtr_dex::ED25519N);
442
443 let keys0 = vec![signer0.verfer().qb64()];
445
446 let serder = InceptionEventBuilder::new(keys0).build()?;
448
449 let ked = serder.ked();
451
452 let raw_str = std::str::from_utf8(serder.raw()).expect("Bad raw");
453
454 assert_eq!(
456 ked["i"].as_str(),
457 Some("BFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH")
458 );
459
460 if let Some(ndigs) = ked["n"].as_array() {
462 assert!(ndigs.is_empty());
463 } else {
464 assert!(true); }
466
467 let raw = serder.raw();
470 assert_eq!(raw, b"{\"v\":\"KERI10JSON0000fd_\",\"t\":\"icp\",\"d\":\"EMW0zK3bagYPO6gx3w7Ua90f-I7x5kGIaI4X\
473 eq9W8_As\",\"i\":\"BFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"0\",\"kt\":\"1\
474 \",\"k\":[\"BFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":\"0\",\"n\":[],\"bt\":\
475 \"0\",\"b\":[],\"c\":[],\"a\":[]}");
476 Ok(())
477 }
478
479 #[test]
480 fn test_inception_event_builder_with_thresholds() -> Result<(), Box<dyn Error>> {
481 let keys = vec![
483 "DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string(),
484 "DVcuJOOJF1IE8svqEtrSuyQjGTd2HhfAkt9y2QkUtFJI".to_string(),
485 "DT1iAhBWCkvChxNWsby2J0pJyxBIxbAtbLA0Ljx-Grh8".to_string(),
486 ];
487
488 let configs = vec!["EO".to_string()];
489
490 let serder = InceptionEventBuilder::new(keys.clone())
492 .with_isith(TholderSith::Integer(2)) .with_ndigs(vec![
494 "EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4".to_string(),
495 "EIAQI--Q9LC48CM_ZyzjM-w-GfqkFkO-6lJ9klGt1fS8".to_string(),
496 ])
497 .with_nsith(TholderSith::Integer(1)) .with_wits(vec![
499 "BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha".to_string(),
500 "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string(),
501 ])
502 .with_toad(2) .with_cnfg(configs) .build()?;
505
506 let ked = serder.ked();
508
509 assert_eq!(ked["v"].as_str(), Some("KERI10JSON000219_"));
510 assert_eq!(ked["t"].as_str(), Some("icp"));
511 assert_eq!(
512 ked["d"].as_str(),
513 Some("EBJ57YenBaTk-SvA5hDVf4KPKmotcKe-8imGK4bSu5xY")
514 );
515 assert_eq!(
516 ked["i"].as_str(),
517 Some("EBJ57YenBaTk-SvA5hDVf4KPKmotcKe-8imGK4bSu5xY")
518 );
519
520 if let Some(k) = ked["k"].as_array() {
522 let ks: Vec<String> = k.iter().map(|k| k.as_str().unwrap().to_string()).collect();
523 assert_eq!(ks, keys);
524 } else {
525 panic!("Keys missing in KED");
526 }
527
528 assert_eq!(ked["kt"].as_str(), Some("2"));
530 assert_eq!(ked["nt"].as_str(), Some("1"));
531 assert_eq!(ked["bt"].as_str(), Some("2"));
532
533 if let Some(wits) = ked["b"].as_array() {
535 assert_eq!(wits.len(), 2);
536 assert_eq!(
537 wits[0],
538 SadValue::String("BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha".to_string())
539 );
540 assert_eq!(
541 wits[1],
542 SadValue::String("BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string())
543 );
544 } else {
545 panic!("Witnesses missing in KED");
546 }
547
548 if let Some(configs) = ked["c"].as_array() {
550 assert_eq!(configs.len(), 1);
551 assert_eq!(configs[0], SadValue::String("EO".to_string()));
552 } else {
553 panic!("Config missing in KED");
554 }
555
556 Ok(())
557 }
558
559 #[test]
560 fn test_inception_event_builder_delegation() -> Result<(), Box<dyn Error>> {
561 let delegator_prefix = "EP1JJCqTdVteCPBqhQ_MqIagD-cplDS_LXoQG-rDd6j4".to_string();
563
564 let keys = vec!["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA".to_string()];
565
566 let serder = InceptionEventBuilder::new(keys)
567 .with_delpre(delegator_prefix.clone())
568 .build()?;
569
570 let ked = serder.ked();
572
573 assert_eq!(ked["t"].as_str(), Some("dip"));
575
576 assert_eq!(ked["di"].as_str(), Some(delegator_prefix.as_str()));
578
579 Ok(())
580 }
581
582 #[test]
583 fn test_inception_transferable_case_abandoned() -> Result<(), Box<dyn Error>> {
584 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
586 \xc9\xbd\x04\x9d\x85)~\x93";
587
588 let signer0 = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
589 assert_eq!(signer0.code(), mtr_dex::ED25519_SEED);
590 assert_eq!(signer0.verfer().code(), mtr_dex::ED25519);
591
592 let keys0 = vec![signer0.verfer().qb64()];
593
594 let serder = InceptionEventBuilder::new(keys0).build()?;
596
597 assert_eq!(
598 serder.ked()["i"].as_str().unwrap(),
599 "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH"
600 );
601 assert!(serder.ked()["n"].as_array().unwrap().is_empty());
602
603 assert_eq!(serder.raw(), b"{\"v\":\"KERI10JSON0000fd_\",\"t\":\"icp\",\"d\":\"EPLRRJFe2FHdXKVTkSEX4xb4x-YaPFJ2Xds1\
604 vhtNTd4n\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"0\",\"kt\":\"1\
605 \",\"k\":[\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":\"0\",\"n\":[],\"bt\":\
606 \"0\",\"b\":[],\"c\":[],\"a\":[]}");
607
608 Ok(())
609 }
610
611 #[test]
612 fn test_inception_transferable_not_abandoned_self_addressing() -> Result<(), Box<dyn Error>> {
613 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
615 \xc9\xbd\x04\x9d\x85)~\x93";
616
617 let signer0 = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
618 let keys0 = vec![signer0.verfer().qb64()];
619
620 let seed1 = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
622 \x98Y\xdd\xe8";
623
624 let signer1 = Signer::new(Some(seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
625 assert_eq!(signer1.code(), mtr_dex::ED25519_SEED);
626 assert_eq!(signer1.verfer().code(), mtr_dex::ED25519);
627
628 let nxt1 =
630 vec![Diger::from_ser(&signer1.verfer().qb64b(), Some(mtr_dex::BLAKE3_256))?.qb64()];
631 assert_eq!(nxt1, vec!["EIf-ENw7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W"]);
632
633 let serder0 = InceptionEventBuilder::new(keys0.clone())
635 .with_ndigs(nxt1.clone())
636 .with_code(mtr_dex::BLAKE3_256.to_string())
637 .build()?;
638
639 let ked = serder0.ked();
640 let pre = ked["i"].as_str().unwrap();
641 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ICP);
642 assert_eq!(ked["d"].as_str().unwrap(), pre);
643 assert_eq!(pre, "EAKCxMOuoRzREVHsHCkLilBrUXTvyenBiuM2QtV8BB0C");
644 assert_eq!(ked["s"].as_str().unwrap(), "0");
645 assert_eq!(ked["kt"].as_str().unwrap(), "1");
646 assert_eq!(ked["nt"].as_str().unwrap(), "1");
647 assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
648 assert_eq!(ked["bt"].as_str().unwrap(), "0");
649
650 assert_eq!(serder0.raw(), b"{\"v\":\"KERI10JSON00012b_\",\"t\":\"icp\",\"d\":\"EAKCxMOuoRzREVHsHCkLilBrUXTvyenBiuM2\
651 QtV8BB0C\",\"i\":\"EAKCxMOuoRzREVHsHCkLilBrUXTvyenBiuM2QtV8BB0C\",\"s\":\"0\",\"kt\":\"1\
652 \",\"k\":[\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":\"1\",\"n\":[\"EIf-EN\
653 w7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W\"],\"bt\":\"0\",\"b\":[],\"c\":[],\"a\":[]}");
654
655 Ok(())
656 }
657
658 #[test]
659 fn test_inception_transferable_not_abandoned_self_addressing_intive(
660 ) -> Result<(), Box<dyn Error>> {
661 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
663 \xc9\xbd\x04\x9d\x85)~\x93";
664
665 let signer0 = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
666 let keys0 = vec![signer0.verfer().qb64()];
667
668 let seed1 = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
670 \x98Y\xdd\xe8";
671
672 let signer1 = Signer::new(Some(seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
673 assert_eq!(signer1.code(), mtr_dex::ED25519_SEED);
674 assert_eq!(signer1.verfer().code(), mtr_dex::ED25519);
675
676 let nxt1 =
678 vec![Diger::from_ser(&signer1.verfer().qb64b(), Some(mtr_dex::BLAKE3_256))?.qb64()];
679 assert_eq!(nxt1, vec!["EIf-ENw7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W"]);
680
681 let serder0 = InceptionEventBuilder::new(keys0.clone())
683 .with_ndigs(nxt1.clone())
684 .with_code(mtr_dex::BLAKE3_256.to_string())
685 .with_intive(true)
686 .build()?;
687
688 let raw_str = std::str::from_utf8(serder0.raw())?;
689
690 let ked = serder0.ked();
691 let pre = ked["i"].as_str().unwrap();
692 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ICP);
693 assert_eq!(ked["d"].as_str().unwrap(), pre);
694 assert_eq!(pre, "EIflL4H4134zYoRM6ls6Q086RLC_BhfNFh5uk-WxvhsL");
695 assert_eq!(ked["s"].as_str().unwrap(), "0");
696 assert!(ked["kt"].is_number()); assert!(ked["nt"].is_number()); assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
699 assert!(ked["bt"].is_number()); assert_eq!(serder0.raw(), b"{\"v\":\"KERI10JSON000125_\",\"t\":\"icp\",\"d\":\"EIflL4H4134zYoRM6ls6Q086RLC_BhfNFh5u\
702 k-WxvhsL\",\"i\":\"EIflL4H4134zYoRM6ls6Q086RLC_BhfNFh5uk-WxvhsL\",\"s\":\"0\",\"kt\":1,\
703 \"k\":[\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":1,\"n\":[\"EIf-ENw7Pr\
704 M52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W\"],\"bt\":0,\"b\":[],\"c\":[],\"a\":[]}");
705
706 Ok(())
707 }
708
709 #[test]
710 fn test_inception_transferable_not_abandoned_intive_true() -> Result<(), Box<dyn Error>> {
711 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
713 \xc9\xbd\x04\x9d\x85)~\x93";
714
715 let signer0 = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
716 let keys0 = vec![signer0.verfer().qb64()];
717
718 let seed1 = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
720 \x98Y\xdd\xe8";
721
722 let signer1 = Signer::new(Some(seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
723 assert_eq!(signer1.code(), mtr_dex::ED25519_SEED);
724 assert_eq!(signer1.verfer().code(), mtr_dex::ED25519);
725
726 let nxt1 =
728 vec![Diger::from_ser(&signer1.verfer().qb64b(), Some(mtr_dex::BLAKE3_256))?.qb64()];
729 assert_eq!(nxt1, vec!["EIf-ENw7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W"]);
730
731 let serder0 = InceptionEventBuilder::new(keys0.clone())
733 .with_ndigs(nxt1.clone())
734 .with_intive(true)
735 .build()?;
736
737 let ked = serder0.ked();
738 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ICP);
739 assert_eq!(
740 ked["i"].as_str().unwrap(),
741 "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH"
742 );
743 assert_eq!(ked["s"].as_str().unwrap(), "0");
744 assert!(ked["kt"].is_number()); assert!(ked["nt"].is_number()); assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
747 assert!(ked["bt"].is_number()); assert_eq!(serder0.raw(), b"{\"v\":\"KERI10JSON000125_\",\"t\":\"icp\",\"d\":\"EFSJqZE0K0WU95dmccrg_8EKSuVSrt4kGIZN\
750 jqWFA_HL\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"0\",\"kt\":1,\
751 \"k\":[\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":1,\"n\":[\"EIf-ENw7Pr\
752 M52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W\"],\"bt\":0,\"b\":[],\"c\":[],\"a\":[]}");
753 Ok(())
754 }
755
756 #[test]
757 fn test_inception_transferable_not_abandoned() -> Result<(), Box<dyn Error>> {
758 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\
760 \xc9\xbd\x04\x9d\x85)~\x93";
761
762 let signer0 = Signer::new(Some(seed), Some(mtr_dex::ED25519_SEED), Some(true))?;
763 let keys0 = vec![signer0.verfer().qb64()];
764
765 let seed1 = b"\x83B~\x04\x94\xe3\xceUQy\x11f\x0c\x93]\x1e\xbf\xacQ\xb5\xd6Y^\xa2E\xfa\x015\
767 \x98Y\xdd\xe8";
768
769 let signer1 = Signer::new(Some(seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
770 assert_eq!(signer1.code(), mtr_dex::ED25519_SEED);
771 assert_eq!(signer1.verfer().code(), mtr_dex::ED25519);
772
773 let nxt1 =
775 vec![Diger::from_ser(&signer1.verfer().qb64b(), Some(mtr_dex::BLAKE3_256))?.qb64()];
776 assert_eq!(nxt1, vec!["EIf-ENw7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W"]);
777
778 let serder0 = InceptionEventBuilder::new(keys0.clone())
780 .with_ndigs(nxt1.clone())
781 .build()?;
782
783 let ked = serder0.ked();
784 assert_eq!(ked["t"].as_str().unwrap(), Ilks::ICP);
785 assert_eq!(
786 ked["i"].as_str().unwrap(),
787 "DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH"
788 );
789 assert_eq!(ked["s"].as_str().unwrap(), "0");
790 assert_eq!(ked["kt"].as_str().unwrap(), "1");
791 assert_eq!(ked["nt"].as_str().unwrap(), "1");
792 assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
793 assert_eq!(ked["bt"].as_str().unwrap(), "0");
794
795 assert_eq!(serder0.raw(), b"{\"v\":\"KERI10JSON00012b_\",\"t\":\"icp\",\"d\":\"EJQUyxnzIAtmZPoq9f4fExeGN0qfJmaFnUEK\
796 TwIiTBPj\",\"i\":\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\",\"s\":\"0\",\"kt\":\"1\
797 \",\"k\":[\"DFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH\"],\"nt\":\"1\",\"n\":[\"EIf-EN\
798 w7PrM52w4H-S7NGU2qVIfraXVIlV9hEAaMHg7W\"],\"bt\":\"0\",\"b\":[],\"c\":[],\"a\":[]}");
799
800 Ok(())
801 }
802}