Skip to main content

libkeri/keri/core/eventing/
incept.rs

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
11/// Builder for creating SerderKERI inception events
12pub struct InceptionEventBuilder {
13    // Required parameters
14    keys: Vec<String>,
15
16    // Optional parameters with defaults
17    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    /// Creates a new InceptionEventBuilder with default values
33    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(), // Default version
44            kind: "JSON".to_string(),                 // Default kind
45            code: None,
46            intive: false,
47            delpre: None,
48        }
49    }
50
51    /// Sets the initial signing threshold (isith)
52    pub fn with_isith(mut self, isith: TholderSith) -> Self {
53        self.isith = Some(isith);
54        self
55    }
56
57    /// Sets the next signing key digests (ndigs)
58    pub fn with_ndigs(mut self, ndigs: Vec<String>) -> Self {
59        self.ndigs = ndigs;
60        self
61    }
62
63    /// Sets the next signing threshold (nsith)
64    pub fn with_nsith(mut self, nsith: TholderSith) -> Self {
65        self.nsith = Some(nsith);
66        self
67    }
68
69    /// Sets the witness threshold (toad)
70    pub fn with_toad(mut self, toad: usize) -> Self {
71        self.toad = Some(toad);
72        self
73    }
74
75    /// Sets the witnesses (wits)
76    pub fn with_wits(mut self, wits: Vec<String>) -> Self {
77        self.wits = wits;
78        self
79    }
80
81    /// Sets the configuration traits (cnfg)
82    pub fn with_cnfg(mut self, cnfg: Vec<String>) -> Self {
83        self.cnfg = cnfg;
84        self
85    }
86
87    /// Sets the data (seal dicts)
88    pub fn with_data(mut self, data: Vec<SadValue>) -> Self {
89        self.data = data;
90        self
91    }
92
93    /// Sets the version
94    pub fn with_version(mut self, version: String) -> Self {
95        self.version = version;
96        self
97    }
98
99    /// Sets the serialization kind
100    pub fn with_kind(mut self, kind: String) -> Self {
101        self.kind = kind;
102        self
103    }
104
105    /// Sets the derivation code for computed prefix
106    pub fn with_code(mut self, code: String) -> Self {
107        self.code = Some(code);
108        self
109    }
110
111    /// Sets whether to use integer representation for thresholds
112    pub fn with_intive(mut self, intive: bool) -> Self {
113        self.intive = intive;
114        self
115    }
116
117    /// Sets the delegator identifier prefix
118    pub fn with_delpre(mut self, delpre: String) -> Self {
119        self.delpre = Some(delpre);
120        self
121    }
122
123    /// Builds the SerderKERI inception event
124    pub fn build(self) -> Result<SerderKERI, KERIError> {
125        // Version string
126        let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
127
128        // Determine ilk based on delpre
129        let ilk = if self.delpre.is_none() { "icp" } else { "dip" };
130
131        // Create sner (sequence number) - must be 0 for inception
132        let sner = Number::from_num(&BigUint::from(0u32))?;
133
134        // Process isith
135        let isith = match self.isith {
136            Some(sith) => sith,
137            None => {
138                // Default to max(1, ceil(len(keys) / 2))
139                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        // Create and validate tholder
146        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        // Process nsith
163        let nsith = match self.nsith {
164            Some(sith) => sith,
165            None => {
166                // Default to max(0, ceil(len(ndigs) / 2))
167                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        // Create and validate ntholder
174        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        // Process witnesses
183        let wits = self.wits;
184
185        // Check for duplicates in wits
186        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        // Process toad
195        let toad = match self.toad {
196            Some(t) => t,
197            None => {
198                if wits.is_empty() {
199                    0
200                } else {
201                    // Compute default threshold using ample function
202                    ample(wits.len())
203                }
204            }
205        };
206
207        // Create toader
208        let toader = Number::from_num(&BigUint::from(toad))?;
209
210        // Validate toad
211        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        // Create a new Sadder object for the KED (Key Event Data)
280        let mut ked = Sadder::default();
281
282        // Set the required fields
283        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())); // qb64 SAID (empty for now)
286        ked.insert("i".to_string(), SadValue::String(String::new())); // qb64 prefix (empty for now)
287        ked.insert("s".to_string(), SadValue::String(sner.numh())); // hex string no leading zeros lowercase
288
289        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                    // Weighted: a list (or list of lists) of fractions, as keripy writes it.
304                    ked.insert("kt".to_string(), super::weights_value(&kt)?);
305                }
306            }
307        };
308
309        // Set the keys list
310        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)); // list of qb64
316
317        // Set next threshold
318        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        // Set next digests list
338        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)); // list of qb64
344
345        // Set witness threshold
346        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        // Set witnesses list
366        let wit_values = wits.iter().map(|w| SadValue::String(w.clone())).collect();
367        ked.insert("b".to_string(), SadValue::Array(wit_values)); // list of qb64
368
369        // Set config traits
370        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)); // list of config ordered mappings may be empty
376
377        // Set data (seal dicts)
378        if !self.data.is_empty() {
379            ked.insert("a".to_string(), SadValue::Array(self.data.clone())); // list of config ordered mappings may be empty
380        }
381
382        // Handle delegated inception
383        if let Some(delpre) = self.delpre.clone() {
384            ked.insert("di".to_string(), SadValue::String(delpre.clone()));
385        } else {
386            // Non-delegated inception
387            if (self.code.is_none() || !is_digest_code(&self.code.as_ref().unwrap()))
388                && self.keys.len() == 1
389            {
390                // Use first key as default identifier
391                ked.insert("i".to_string(), SadValue::String(self.keys[0].clone()));
392            }
393        }
394
395        // Create a HashMap for saids if needed
396        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        // Handle delegated inception
406        let mut saids = HashMap::new();
407        // Use code to override all else if it's a prefix code
408        if let Some(ref code) = self.code {
409            if is_prefix_code(code) {
410                saids.insert("i", code.to_string());
411            }
412        }
413
414        // Create SerderKERI
415        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        // Setup a fixed seed similar to the Python test
435        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        // Create a non-transferable signer (ephemeral case)
439        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        // Extract verfer qb64 for the key
444        let keys0 = vec![signer0.verfer().qb64()];
445
446        // Create inception event using the builder
447        let serder = InceptionEventBuilder::new(keys0).build()?;
448
449        // Verify the key event data
450        let ked = serder.ked();
451
452        let raw_str = std::str::from_utf8(serder.raw()).expect("Bad raw");
453
454        // Check identifier matches our expectations
455        assert_eq!(
456            ked["i"].as_str(),
457            Some("BFs8BBx86uytIM0D2BhsE5rrqVIT8ef8mflpNceHo4XH")
458        );
459
460        // Check next key digests are empty
461        if let Some(ndigs) = ked["n"].as_array() {
462            assert!(ndigs.is_empty());
463        } else {
464            assert!(true); // n is None which is also valid for empty
465        }
466
467        // Check the raw serialized form if needed
468        // This may be challenging due to string serialization differences
469        let raw = serder.raw();
470        // Verify the content contains the expected elements
471        // Instead of checking exact bytes, check for key elements
472        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        // Create multiple keys
482        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        // Create inception event with custom thresholds
491        let serder = InceptionEventBuilder::new(keys.clone())
492            .with_isith(TholderSith::Integer(2)) // 2 of 3 for current keys
493            .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)) // 1 of 2 for next keys
498            .with_wits(vec![
499                "BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha".to_string(),
500                "BLskRTInXnMxWaGqcpSyMgo0nYbalW99cGZESrz3zapM".to_string(),
501            ])
502            .with_toad(2) // Witness threshold
503            .with_cnfg(configs) // Example config
504            .build()?;
505
506        // Verify the key event data
507        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        // Verify key elements
521        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        // Verify thresholds
529        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        // Verify witnesses
534        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        // Verify configs
549        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        // Create a delegated inception
562        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        // Verify the key event data
571        let ked = serder.ked();
572
573        // Check it's a delegated inception
574        assert_eq!(ked["t"].as_str(), Some("dip"));
575
576        // Check delegator prefix
577        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        // Original signing keypair - transferable default
585        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        // Default nxt is empty so abandoned
595        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        // Original signing keypair
614        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        // Next signing keypair - transferable default
621        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        // Compute nxt digest
629        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        // Create inception event with self-addressing and nxt digest
634        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        // Original signing keypair
662        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        // Next signing keypair - transferable default
669        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        // Compute nxt digest
677        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        // Create inception event with self-addressing, nxt digest, and intive=true
682        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()); // Number instead of string
697        assert!(ked["nt"].is_number()); // Number instead of string
698        assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
699        assert!(ked["bt"].is_number()); // Number instead of string
700
701        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        // Original signing keypair
712        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        // Next signing keypair - transferable default
719        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        // Compute nxt digest
727        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        // Create inception event with nxt digest and intive=true
732        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()); // Number instead of string
745        assert!(ked["nt"].is_number()); // Number instead of string
746        assert_eq!(ked["n"].as_array().unwrap()[0].as_str().unwrap(), nxt1[0]);
747        assert!(ked["bt"].is_number()); // Integer instead of string
748
749        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        // Original signing keypair
759        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        // Next signing keypair - transferable default
766        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        // Compute nxt digest
774        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        // Create inception event with nxt digest
779        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}