Skip to main content

libkeri/keri/core/eventing/
mod.rs

1use crate::Matter;
2use std::collections::HashSet;
3use std::error::Error;
4
5use crate::cesr::cigar::Cigar;
6use crate::cesr::non_trans_dex;
7use crate::cesr::seqner::Seqner;
8use crate::keri::core::serdering::{Serder, SerderKERI};
9
10pub mod exchange;
11pub mod incept;
12pub mod interact;
13pub mod kever;
14pub mod kevery;
15pub mod query;
16pub mod receipt;
17pub mod reply;
18pub mod rotate;
19pub mod state;
20
21use crate::cesr::counting::{ctr_dex_1_0, BaseCounter, Counter};
22use crate::cesr::indexing::siger::Siger;
23use crate::cesr::indexing::Indexer;
24use crate::cesr::tholder::Tholder;
25use crate::cesr::verfer::Verfer;
26use crate::keri::KERIError;
27pub use incept::*;
28pub use interact::*;
29pub use kever::*;
30pub use kevery::*;
31pub use query::*;
32pub use receipt::*;
33pub use reply::*;
34pub use rotate::*;
35pub use state::*;
36
37// Determine threshold representations based on intive flag
38const MAX_INT_THOLD: usize = 12; // Define this constant based on your system
39
40fn ample(n: usize) -> usize {
41    // Implementation for ample - computes witness threshold
42    std::cmp::max(1, (n as f64 / 2.0).ceil() as usize)
43}
44
45fn is_digest_code(code: &str) -> bool {
46    // Check if code is in DigDex
47    ["E", "S", "X"].contains(&code)
48}
49
50fn is_prefix_code(code: &str) -> bool {
51    // Check if code is in PreDex
52    ["A", "B", "C", "D"].contains(&code)
53}
54
55/// SealEvent represents a triple (i, s, d) of identifier, sequence number, and digest
56#[derive(Debug, Clone)]
57pub struct SealEvent {
58    pub i: String, // identifier prefix (pre)
59    pub s: String, // sequence number as hex string
60    pub d: String, // digest (said)
61}
62
63impl SealEvent {
64    pub fn new(i: String, s: String, d: String) -> Self {
65        Self { i, s, d }
66    }
67}
68
69/// SealLast represents a single value (i) of identifier
70#[derive(Debug, Clone)]
71pub struct SealLast {
72    pub i: String, // identifier prefix (pre)
73}
74
75impl SealLast {
76    pub fn new(i: String) -> Self {
77        Self { i }
78    }
79}
80
81pub enum Seal {
82    SealLast(SealLast),
83    SealEvent(SealEvent),
84}
85
86/// Attaches indexed signatures from sigers and/or cigars and/or wigers to KERI message data from serder
87///
88/// # Arguments
89///
90/// * `serder` - SerderKERI instance containing the event
91/// * `sigers` - Optional list of Siger instances to create indexed signatures
92/// * `seal` - Optional seal:
93///     - If SealEvent: Use attachment group code TransIdxSigGroups plus attach
94///       triple pre+snu+dig made from (i,s,d) of seal plus ControllerIdxSigs
95///       plus attached indexed sigs in sigers
96///     - If SealLast: Use attachment group code TransLastIdxSigGroups plus
97///       attach triple pre made from (i) of seal plus ControllerIdxSigs
98///       plus attached indexed sigs in sigers
99///     - Else: Use ControllerIdxSigs plus attached indexed sigs in sigers
100/// * `wigers` - Optional list of Siger instances of witness index signatures
101/// * `cigars` - Optional list of Cigars instances of non-transferable non indexed
102///   signatures from which to form receipt couples.
103///   Each cigar.verfer.qb64 is pre of receiptor and cigar.qb64 is signature
104/// * `pipelined` - If true, prepend pipelining count code to attachemnts
105///   If false, do not prepend pipelining count code
106///
107/// # Returns
108///
109/// Bytearray containing the KERI event message
110///
111/// # Errors
112///
113/// Returns an error if there are no signatures attached or if there are invalid attachment sizes
114pub fn validate_sigs(
115    serder: &SerderKERI,
116    sigers: Vec<Siger>,
117    verfers: &[Verfer],
118    tholder: &Tholder,
119) -> Result<(Vec<Siger>, bool), KERIError> {
120    // Check if we have enough verfers for the threshold
121    if verfers.len() < tholder.size() {
122        let verfer_qb64s: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
123        return Err(KERIError::ValidationError(format!(
124            "Invalid sith = {} for keys = {:?}",
125            tholder.sith(),
126            verfer_qb64s
127        )));
128    }
129
130    // Get unique verified sigers and indices lists from sigers list
131    let (verified_sigers, indices) = verify_sigs(serder.raw(), sigers, verfers)?;
132    // verified_sigers now have .verfer assigned
133
134    // Check if we have at least one verified signature
135    if indices.is_empty() {
136        return Err(KERIError::ValidationError(format!(
137            "No verified signatures for message={:?}",
138            serder.ked()
139        )));
140    }
141
142    // Check if satisfies threshold for fully signed
143    let valid = tholder.satisfy(&indices);
144
145    Ok((verified_sigers, valid))
146}
147
148pub fn messagize(
149    serder: &SerderKERI,
150    sigers: Option<&[Siger]>,
151    seal: Option<Seal>,
152    wigers: Option<&[Siger]>,
153    cigars: Option<&[Cigar]>,
154    pipelined: bool,
155) -> Result<Vec<u8>, Box<dyn Error>> {
156    let mut msg = serder.raw().to_vec(); // make copy of raw bytes
157    let mut atc = Vec::new(); // attachment bytearray
158
159    if sigers.is_none() && cigars.is_none() && wigers.is_none() {
160        return Err("Missing attached signatures on message".into());
161    }
162
163    if let Some(sigers_slice) = sigers {
164        if !sigers_slice.is_empty() {
165            // Check if we have a seal
166            if let Some(seal_any) = seal {
167                // Try to downcast to SealEvent
168                match seal_any {
169                    Seal::SealLast(seal_last) => {
170                        let counter = BaseCounter::from_code_and_count(
171                            Some(ctr_dex_1_0::TRANS_LAST_IDX_SIG_GROUPS),
172                            Some(1),
173                            None,
174                        )?;
175                        atc.extend(counter.qb64b());
176
177                        // Append seal data
178                        atc.extend(seal_last.i.as_bytes());
179                    }
180                    Seal::SealEvent(seal_event) => {
181                        let counter = BaseCounter::from_code_and_count(
182                            Some(ctr_dex_1_0::TRANS_IDX_SIG_GROUPS),
183                            Some(1),
184                            None,
185                        )?;
186                        atc.extend(counter.qb64b());
187
188                        // Append seal data
189                        atc.extend(seal_event.i.as_bytes());
190                        let seqner = Seqner::from_snh(&seal_event.s)?;
191                        atc.extend(seqner.qb64b());
192                        atc.extend(seal_event.d.as_bytes());
193                    }
194                }
195            }
196
197            // Add controller indexed signatures
198            let counter = BaseCounter::from_code_and_count(
199                Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
200                Some(sigers_slice.len() as u64),
201                None,
202            )?;
203            atc.extend(counter.qb64b());
204
205            for siger in sigers_slice {
206                atc.extend(siger.qb64b());
207            }
208        }
209    }
210
211    if let Some(wigers_slice) = wigers {
212        if !wigers_slice.is_empty() {
213            // Add witness indexed signatures
214            let counter = BaseCounter::from_code_and_count(
215                Some(ctr_dex_1_0::WITNESS_IDX_SIGS),
216                Some(wigers_slice.len() as u64),
217                None,
218            )?;
219            atc.extend(counter.qb64b());
220
221            for wiger in wigers_slice {
222                // Check if non-transferable
223                if let Some(verfer) = &wiger.verfer() {
224                    if !non_trans_dex::TUPLE.contains(&verfer.code()) {
225                        return Err(format!(
226                            "Attempt to use tranferable prefix={} for receipt.",
227                            verfer.qb64()
228                        )
229                        .into());
230                    }
231                }
232                atc.extend(wiger.qb64b());
233            }
234        }
235    }
236
237    if let Some(cigars_slice) = cigars {
238        if !cigars_slice.is_empty() {
239            // Add non-transferable receipt couples
240            let counter = BaseCounter::from_code_and_count(
241                Some(ctr_dex_1_0::NON_TRANS_RECEIPT_COUPLES),
242                Some(cigars_slice.len() as u64),
243                None,
244            )?;
245            atc.extend(counter.qb64b());
246
247            for cigar in cigars_slice {
248                // Check if non-transferable
249                if !non_trans_dex::TUPLE.contains(&cigar.verfer().unwrap().code()) {
250                    return Err(format!(
251                        "Attempt to use tranferable prefix={} for receipt.",
252                        cigar.verfer().unwrap().qb64()
253                    )
254                    .into());
255                }
256
257                // Append verfer and signature
258                atc.extend(cigar.verfer().unwrap().qb64b());
259                atc.extend(cigar.qb64b());
260            }
261        }
262    }
263
264    if pipelined {
265        // Check that attachments size is a multiple of 4 (integral quadlets)
266        if atc.len() % 4 != 0 {
267            return Err(format!(
268                "Invalid attachments size={}, nonintegral quadlets.",
269                atc.len()
270            )
271            .into());
272        }
273
274        // Add attachment group counter
275        let counter = BaseCounter::from_code_and_count(
276            Some(ctr_dex_1_0::ATTACHMENT_GROUP),
277            Some((atc.len() / 4) as u64),
278            None,
279        )?;
280        msg.extend(counter.qb64b());
281    }
282
283    // Add attachments to message
284    msg.extend(atc);
285
286    Ok(msg)
287}
288
289/// Verifies signatures against verifiers and returns verified signatures and their indices
290///
291/// Returns tuple of (vsigers, vindices) where:
292/// - vsigers is a list of unique verified sigers with assigned verfer
293/// - vindices is a list of indices from those verified sigers
294///
295/// The returned vsigers and vindices may be used for threshold validation
296///
297/// Assigns appropriate verfer from verfers to each siger based on siger index
298/// If no signatures verify then sigers and indices are empty
299///
300/// # Arguments
301///
302/// * `raw` - The signed data as bytes
303/// * `sigers` - A list of indexed Siger instances (signatures)
304/// * `verfers` - A list of Verfer instances (public keys)
305///
306/// # Returns
307///
308/// * `Result<(Vec<Siger>, Vec<usize>), KERIError>` - Tuple of verified sigers and their indices
309fn verify_sigs(
310    raw: &[u8],
311    sigers: Vec<Siger>,
312    verfers: &[Verfer],
313) -> Result<(Vec<Siger>, Vec<usize>), KERIError> {
314    if sigers.is_empty() {
315        return Ok((Vec::new(), Vec::new()));
316    }
317
318    // Create a set of unique signatures to avoid duplicates
319    // In Rust, we'll use a HashSet to collect unique sigers based on their qb64
320    let mut unique_signatures = HashSet::new();
321    let mut unique_sigers = Vec::new();
322
323    for siger in sigers {
324        let qb64 = siger.qb64();
325        if unique_signatures.insert(qb64) {
326            unique_sigers.push(siger);
327        }
328    }
329
330    // Create a vector to hold sigers with assigned verfers
331    let mut usigers_with_verfers = Vec::new();
332
333    // Assign verfers to each unique siger based on index
334    for mut siger in unique_sigers {
335        let index = siger.index() as usize;
336        if index >= verfers.len() {
337            // Log if index is out of bounds
338            continue;
339        }
340
341        // Clone the verfer and assign it to the siger
342        let verfer = verfers[index].clone();
343        siger.set_verfer(verfer);
344        usigers_with_verfers.push(siger);
345    }
346
347    // Create lists of verified sigers and their indices
348    let mut vindices = Vec::new();
349    let mut vsigers = Vec::new();
350
351    // Verify each siger and collect valid ones
352    for siger in usigers_with_verfers {
353        // Get verfer from siger - it should be present now
354        if let Some(verfer) = siger.verfer() {
355            // Verify the signature
356            match verfer.verify(siger.raw(), raw) {
357                Ok(true) => {
358                    // Signature verified successfully
359                    vindices.push(siger.index() as usize);
360                    vsigers.push(siger);
361                }
362                Ok(false) => {
363                    // Signature failed verification
364                    print!("Signature failed verification for index {}", siger.index());
365                }
366                Err(err) => {
367                    // Error during verification
368                    print!(
369                        "Error verifying signature at index {}: {:?}",
370                        siger.index(),
371                        err
372                    );
373                }
374            }
375        } else {
376            // This shouldn't happen if we properly assigned verfers above
377            print!("Siger missing verfer at index {}", siger.index());
378        }
379    }
380
381    Ok((vsigers, vindices))
382}
383
384#[cfg(test)]
385mod tests {
386    use super::*;
387    use crate::cesr::signing::{Salter, Sigmat};
388    use crate::cesr::{mtr_dex, Matter};
389    use crate::keri::app::keeping::{Keeper, Manager};
390    use crate::keri::core::eventing::interact::InteractEventBuilder;
391    use crate::keri::core::eventing::rotate::RotateEventBuilder;
392    use crate::keri::core::serdering::SadValue;
393    use crate::keri::db::dbing::LMDBer;
394    use indexmap::IndexMap;
395    use std::error::Error;
396    use std::sync::Arc;
397
398    #[test]
399    fn test_messagize() -> Result<(), Box<dyn Error>> {
400        // Create deterministic salter for testing
401        let raw = b"0123456789abcdef";
402        let salter = Salter::new(Some(raw), None, None)?;
403        assert_eq!(salter.qb64b(), b"0AAwMTIzNDU2Nzg5YWJjZGVm");
404
405        let lmdber = LMDBer::builder()
406            .name("manager_ks")
407            .reopen(true)
408            .build()
409            .expect("Failed to open manager database: {}");
410        let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
411        let mut manager = Manager::new(keeper, None, None, None, None, Some(salter.qb64b()), None)?;
412        // Test salty algorithm incept
413        let (verfers, digers) = manager.incept(
414            None,
415            Some(1),
416            None,
417            None,
418            Some(0),
419            None,
420            None,
421            None,
422            None,
423            Some("C"),
424            None,
425            None,
426            Some(true),
427            None,
428        )?;
429        assert_eq!(verfers.len(), 1);
430        assert_eq!(digers.len(), 0);
431        assert_eq!(
432            verfers[0].qb64b(),
433            b"DOif48whAmpb_4kyksMcz57snMRIuX0bqN1FDe09AlRj"
434        );
435
436        // Create inception event
437        let serder = InceptionEventBuilder::new(vec![verfers[0].qb64()])
438            .with_code(mtr_dex::BLAKE3_256.to_string())
439            .build()?;
440
441        // Sign the serialized event
442        let sigers: Vec<Siger> = manager
443            .sign(
444                serder.raw(),
445                None,
446                Some(verfers),
447                None,
448                None,
449                None,
450                None,
451                None,
452            )?
453            .iter()
454            .map(|sigmat| match sigmat {
455                Sigmat::Indexed(siger) => siger.clone(),
456                Sigmat::NonIndexed(_) => {
457                    panic!("Unexpected non-indexed signature");
458                }
459            })
460            .collect();
461
462        // Test basic messagize with sigers
463        let msg = messagize(&serder, Some(&sigers), None, None, None, false)?;
464
465        // Expected output for basic case
466        assert_eq!(
467            String::from_utf8(msg.clone())?,
468            concat!(
469                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
470                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
471                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
472                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-AA"#,
473                r#"BAAB1DuEfnZZ6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5lPfP"#,
474                r#"QQkQkxI862_XjyZLHyClVTLoD"#
475            )
476        );
477
478        // Test with pipelined
479        let msg = messagize(&serder, Some(&sigers), None, None, None, true)?;
480
481        // Expected output for pipelined case
482        assert_eq!(
483            String::from_utf8(msg.clone())?,
484            concat!(
485                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
486                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
487                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
488                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VA"#,
489                r#"X-AABAAB1DuEfnZZ6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5"#,
490                r#"lPfPQQkQkxI862_XjyZLHyClVTLoD"#
491            )
492        );
493
494        // Test with SealEvent
495        let seal = Seal::SealEvent(SealEvent::new(
496            "DAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI".to_string(),
497            "0".to_string(),
498            "EMuNWHss_H_kH4cG7Li1jn2DXfrEaqN7zhqTEhkeDZ2z".to_string(),
499        ));
500
501        let msg = messagize(&serder, Some(&sigers), Some(seal), None, None, false)?;
502
503        // Expected output with SealEvent
504        assert_eq!(
505            String::from_utf8(msg.clone())?,
506            concat!(
507                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
508                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
509                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
510                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-FA"#,
511                r#"BDAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI0AAAAAAAAAAAAAAAAAA"#,
512                r#"AAAAAEMuNWHss_H_kH4cG7Li1jn2DXfrEaqN7zhqTEhkeDZ2z-AABAAB1DuEfnZZ"#,
513                r#"6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5lPfPQQkQkxI862_X"#,
514                r#"jyZLHyClVTLoD"#
515            )
516        );
517
518        // Test SealEvent with pipelined
519        // Test with SealEvent
520        let seal = Seal::SealEvent(SealEvent::new(
521            "DAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI".to_string(),
522            "0".to_string(),
523            "EMuNWHss_H_kH4cG7Li1jn2DXfrEaqN7zhqTEhkeDZ2z".to_string(),
524        ));
525        let msg = messagize(&serder, Some(&sigers), Some(seal), None, None, true)?;
526
527        // Expected output for SealEvent with pipelined
528        assert_eq!(
529            String::from_utf8(msg.clone())?,
530            concat!(
531                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
532                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
533                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
534                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VA"#,
535                r#"0-FABDAvCLRr5luWmp7keDvDuLP0kIqcyBYq79b3Dho1QvrjI0AAAAAAAAAAAAAA"#,
536                r#"AAAAAAAAAEMuNWHss_H_kH4cG7Li1jn2DXfrEaqN7zhqTEhkeDZ2z-AABAAB1DuE"#,
537                r#"fnZZ6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5lPfPQQkQkxI8"#,
538                r#"62_XjyZLHyClVTLoD"#
539            )
540        );
541
542        let (verfers, digers) = manager.incept(
543            None,
544            Some(1),
545            None,
546            None,
547            Some(0),
548            None,
549            None,
550            None,
551            None,
552            Some("W"),
553            None,
554            None,
555            Some(false),
556            None,
557        )?;
558
559        // Test with wigers
560        // First create a non-transferable signer
561        let wigers: Vec<Siger> = manager
562            .sign(
563                serder.raw(),
564                None,
565                Some(verfers),
566                None,
567                None,
568                None,
569                None,
570                None,
571            )?
572            .iter()
573            .map(|sigmat| match sigmat {
574                Sigmat::Indexed(siger) => siger.clone(),
575                Sigmat::NonIndexed(_) => {
576                    panic!("Unexpected non-indexed signature");
577                }
578            })
579            .collect();
580
581        let msg = messagize(&serder, None, None, Some(&wigers), None, false)?;
582
583        // Expected output for wigers
584        assert_eq!(
585            String::from_utf8(msg.clone())?,
586            concat!(
587                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
588                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
589                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
590                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-BA"#,
591                r#"BAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyxs7_JuO4RioH1NUTtzTuV1bbuB7eoNhEj"#,
592                r#"20VJYa4947ZMVrOxKhzI6EqUH"#
593            )
594        );
595
596        // Test wigers with pipelined
597        let msg = messagize(&serder, None, None, Some(&wigers), None, true)?;
598
599        // Expected output for wigers with pipelined
600        assert_eq!(
601            String::from_utf8(msg.clone())?,
602            concat!(
603                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
604                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
605                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
606                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VA"#,
607                r#"X-BABAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyxs7_JuO4RioH1NUTtzTuV1bbuB7eo"#,
608                r#"NhEj20VJYa4947ZMVrOxKhzI6EqUH"#
609            )
610        );
611
612        // Test with cigars
613        // Create a non-transferable signer for cigars (non-indexed signatures)
614        let (verfers, digers) = manager.incept(
615            None,
616            Some(1),
617            None,
618            None,
619            Some(0),
620            None,
621            None,
622            None,
623            None,
624            Some("R"),
625            None,
626            None,
627            Some(false),
628            None,
629        )?;
630
631        let cigars: Vec<Cigar> = manager
632            .sign(
633                serder.raw(),
634                None,
635                Some(verfers),
636                Some(false),
637                None,
638                None,
639                None,
640                None,
641            )?
642            .iter()
643            .map(|sigmat| match sigmat {
644                Sigmat::Indexed(siger) => {
645                    panic!("Unexpected non-indexed signature");
646                }
647                Sigmat::NonIndexed(cigar) => cigar.clone(),
648            })
649            .collect();
650        let msg = messagize(&serder, None, None, None, Some(&cigars), false)?;
651
652        // Expected output for cigars
653        assert_eq!(
654            String::from_utf8(msg.clone())?,
655            concat!(
656                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
657                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
658                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
659                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-CA"#,
660                r#"BBJjH1MCDssEZMnORskF34AwOFDgDL47513GivRvd_QKz0BDwWrxO8RItpgGFtFi"#,
661                r#"DF7QoVas-6Bzvj0xtOfbsh31jjtshcEa0rUVX2xsyyH1US2fBWe7FNpn6xko5EVw"#,
662                r#"g_TwF"#
663            )
664        );
665
666        // Test cigars with pipelined
667        let msg = messagize(&serder, None, None, None, Some(&cigars), true)?;
668
669        // Expected output for cigars with pipelined
670        assert_eq!(
671            String::from_utf8(msg.clone())?,
672            concat!(
673                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
674                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
675                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
676                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VA"#,
677                r#"i-CABBJjH1MCDssEZMnORskF34AwOFDgDL47513GivRvd_QKz0BDwWrxO8RItpgG"#,
678                r#"FtFiDF7QoVas-6Bzvj0xtOfbsh31jjtshcEa0rUVX2xsyyH1US2fBWe7FNpn6xko"#,
679                r#"5EVwg_TwF"#
680            )
681        );
682
683        // Test with wigers and cigars
684        let msg = messagize(&serder, None, None, Some(&wigers), Some(&cigars), false)?;
685
686        // Expected output for wigers and cigars
687        assert_eq!(
688            String::from_utf8(msg.clone())?,
689            concat!(
690                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
691                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
692                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
693                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-BA"#,
694                r#"BAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyxs7_JuO4RioH1NUTtzTuV1bbuB7eoNhEj"#,
695                r#"20VJYa4947ZMVrOxKhzI6EqUH-CABBJjH1MCDssEZMnORskF34AwOFDgDL47513G"#,
696                r#"ivRvd_QKz0BDwWrxO8RItpgGFtFiDF7QoVas-6Bzvj0xtOfbsh31jjtshcEa0rUV"#,
697                r#"X2xsyyH1US2fBWe7FNpn6xko5EVwg_TwF"#
698            )
699        );
700
701        // Test with wigers and cigars and pipelined
702        let msg = messagize(&serder, None, None, Some(&wigers), Some(&cigars), true)?;
703
704        // Expected output for wigers and cigars with pipelined
705        assert_eq!(
706            String::from_utf8(msg.clone())?,
707            concat!(
708                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
709                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
710                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
711                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VA"#,
712                r#"5-BABAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyxs7_JuO4RioH1NUTtzTuV1bbuB7eo"#,
713                r#"NhEj20VJYa4947ZMVrOxKhzI6EqUH-CABBJjH1MCDssEZMnORskF34AwOFDgDL47"#,
714                r#"513GivRvd_QKz0BDwWrxO8RItpgGFtFiDF7QoVas-6Bzvj0xtOfbsh31jjtshcEa"#,
715                r#"0rUVX2xsyyH1US2fBWe7FNpn6xko5EVwg_TwF"#
716            )
717        );
718
719        // Test with sigers, wigers, and cigars
720        let msg = messagize(
721            &serder,
722            Some(&sigers),
723            None,
724            Some(&wigers),
725            Some(&cigars),
726            false,
727        )?;
728
729        // Expected output for sigers, wigers, and cigars
730        assert_eq!(
731            String::from_utf8(msg.clone())?,
732            concat!(
733                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
734                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
735                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
736                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-AA"#,
737                r#"BAAB1DuEfnZZ6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5lPfP"#,
738                r#"QQkQkxI862_XjyZLHyClVTLoD-BABAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyxs7_J"#,
739                r#"uO4RioH1NUTtzTuV1bbuB7eoNhEj20VJYa4947ZMVrOxKhzI6EqUH-CABBJjH1MC"#,
740                r#"DssEZMnORskF34AwOFDgDL47513GivRvd_QKz0BDwWrxO8RItpgGFtFiDF7QoVas"#,
741                r#"-6Bzvj0xtOfbsh31jjtshcEa0rUVX2xsyyH1US2fBWe7FNpn6xko5EVwg_TwF"#
742            )
743        );
744
745        // Test with sigers, wigers, cigars and pipelined
746        let msg = messagize(
747            &serder,
748            Some(&sigers),
749            None,
750            Some(&wigers),
751            Some(&cigars),
752            true,
753        )?;
754
755        // Expected output for sigers, wigers, cigars with pipelined
756        assert_eq!(
757            String::from_utf8(msg)?,
758            concat!(
759                r#"{"v":"KERI10JSON0000fd_","t":"icp","d":"EFyzzg2Mp5A3ecChc6AhSLTQ"#,
760                r#"ssBZAmNvPnGxjJyHxl4F","i":"EFyzzg2Mp5A3ecChc6AhSLTQssBZAmNvPnGxj"#,
761                r#"JyHxl4F","s":"0","kt":"1","k":["DOif48whAmpb_4kyksMcz57snMRIuX0b"#,
762                r#"qN1FDe09AlRj"],"nt":"0","n":[],"bt":"0","b":[],"c":[],"a":[]}-VB"#,
763                r#"Q-AABAAB1DuEfnZZ6juMZDYiodcWiIqdjuEE-QzdORp-DbxdDN_GG84x_NA1rSc5"#,
764                r#"lPfPQQkQkxI862_XjyZLHyClVTLoD-BABAABtOhjlKo8WhJQ3EXMIMaQ_IH6yeyx"#,
765                r#"s7_JuO4RioH1NUTtzTuV1bbuB7eoNhEj20VJYa4947ZMVrOxKhzI6EqUH-CABBJj"#,
766                r#"H1MCDssEZMnORskF34AwOFDgDL47513GivRvd_QKz0BDwWrxO8RItpgGFtFiDF7Q"#,
767                r#"oVas-6Bzvj0xtOfbsh31jjtshcEa0rUVX2xsyyH1US2fBWe7FNpn6xko5EVwg_TwF"#
768            )
769        );
770
771        Ok(())
772    }
773
774    #[test]
775    fn test_full_kel() -> Result<(), Box<dyn Error>> {
776        // Create deterministic salter for testing
777        let raw = b"abcdef0123456789";
778        let salter = Salter::new(Some(raw), None, None)?;
779        assert_eq!(salter.qb64(), "0ABhYmNkZWYwMTIzNDU2Nzg5");
780
781        let lmdber = LMDBer::builder()
782            .name("manager_ks")
783            .reopen(true)
784            .build()
785            .expect("Failed to open manager database: {}");
786        let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
787        let mut manager = Manager::new(keeper, None, None, None, None, Some(salter.qb64b()), None)?;
788        // Test salty algorithm incept
789        let (verfers, digers) = manager.incept(
790            None,
791            Some(1),
792            None,
793            None,
794            Some(1),
795            None,
796            None,
797            None,
798            None,
799            Some("C"),
800            None,
801            None,
802            Some(true),
803            None,
804        )?;
805        assert_eq!(verfers.len(), 1);
806        assert_eq!(digers.len(), 1);
807        assert_eq!(
808            verfers[0].qb64(),
809            "DCjMCQ638m293JGMIjU7ch0bqmaU6-v4AK_wBf6jl4OX"
810        );
811        assert_eq!(
812            digers[0].qb64(),
813            "EEyU3aS2N1JrMq5kDQ4tZ_5PBTRD8ISUx3WUsuj0rU3-"
814        );
815
816        // Create inception event
817        let serder = InceptionEventBuilder::new(vec![verfers[0].qb64()])
818            .with_code(mtr_dex::BLAKE3_256.to_string())
819            .with_ndigs(vec![digers[0].qb64()])
820            .build()?;
821
822        let oldspre = verfers[0].qb64b();
823        let spre = serder.preb().unwrap();
824        manager.move_prefix(&oldspre, &spre)?;
825
826        // Sign the serialized event
827        let sigers: Vec<Siger> = manager
828            .sign(
829                serder.raw(),
830                None,
831                Some(verfers),
832                None,
833                None,
834                None,
835                None,
836                None,
837            )?
838            .iter()
839            .map(|sigmat| match sigmat {
840                Sigmat::Indexed(siger) => siger.clone(),
841                Sigmat::NonIndexed(_) => {
842                    panic!("Unexpected non-indexed signature");
843                }
844            })
845            .collect();
846
847        // Lets collect the full KEL
848        let mut kel = String::new();
849
850        // Test basic messagize with sigers
851        let msg = messagize(&serder, Some(&sigers), None, None, None, false)?;
852        kel.push_str(&String::from_utf8(msg.clone())?);
853
854        assert_eq!(
855            String::from_utf8(msg)?,
856            concat!(
857                r#"{"v":"KERI10JSON00012b_","t":"icp","d":"EPXgQxGLRPBzBR84e6hZ_SY1l5-WJU8b_n8ibASNDfKM","#,
858                r#""i":"EPXgQxGLRPBzBR84e6hZ_SY1l5-WJU8b_n8ibASNDfKM","s":"0","kt":"1","k":["#,
859                r#""DCjMCQ638m293JGMIjU7ch0bqmaU6-v4AK_wBf6jl4OX"],"nt":"1","n":["EEyU3aS2N1JrMq5k"#,
860                r#"DQ4tZ_5PBTRD8ISUx3WUsuj0rU3-"],"bt":"0","b":[],"c":[],"a":[]}-AABAABGkiiW6C8_"#,
861                r#"TTeT0XuWuxjrQ4Fp7hkurrP2oqYFBKMTYcoZDa5_ekzjQDOMX6cCZVeUBbbFnB0D7EX36vz385sM"#
862            )
863        );
864
865        let (verfers, digers) = manager.rotate(
866            &serder.preb().unwrap(),
867            None,
868            Some(1),
869            None,
870            None,
871            Some(true),
872            Some(false),
873            Some(false),
874        )?;
875        assert_eq!(verfers.len(), 1);
876        assert_eq!(digers.len(), 1);
877        assert_eq!(
878            verfers[0].qb64(),
879            "DDxkQL-tXDKwAKPnVpmKgmeIP5GAa4nSI6pWFbuYc8Ye"
880        );
881        assert_eq!(
882            digers[0].qb64(),
883            "EBIjhA2t-Sfm29atirPEG-VD9ouVzy7i7PrFslG6D7tm"
884        );
885
886        let rserder = RotateEventBuilder::new(
887            serder.pre().unwrap(),
888            vec![verfers[0].qb64()],
889            serder.said().unwrap().to_string(),
890        )
891        .with_ndigs(vec![digers[0].qb64()])
892        .build()?;
893
894        // Sign the serialized event
895        let rsigers: Vec<Siger> = manager
896            .sign(
897                rserder.raw(),
898                None,
899                Some(verfers.clone()),
900                None,
901                None,
902                None,
903                None,
904                None,
905            )?
906            .iter()
907            .map(|sigmat| match sigmat {
908                Sigmat::Indexed(siger) => siger.clone(),
909                Sigmat::NonIndexed(_) => {
910                    panic!("Unexpected non-indexed signature");
911                }
912            })
913            .collect();
914
915        // Test rotation with messagize with sigers
916        let msg = messagize(&rserder, Some(&rsigers), None, None, None, false)?;
917        kel.push_str(&String::from_utf8(msg.clone())?);
918        assert_eq!(
919            String::from_utf8(msg)?,
920            concat!(
921                r#"{"v":"KERI10JSON000160_","t":"rot","d":"EFFvfdKjytGurVS52KzF5NefoQkVJp9w3vDb5is9mEzP","#,
922                r#""i":"EPXgQxGLRPBzBR84e6hZ_SY1l5-WJU8b_n8ibASNDfKM","s":"1","p":"EPXgQxGLRPBzBR84e6hZ_"#,
923                r#"SY1l5-WJU8b_n8ibASNDfKM","kt":"1","k":["DDxkQL-tXDKwAKPnVpmKgmeIP5GAa4nSI6pWFbuYc8Ye"],"#,
924                r#""nt":"1","n":["EBIjhA2t-Sfm29atirPEG-VD9ouVzy7i7PrFslG6D7tm"],"bt":"0","br":[],"ba":[],"#,
925                r#""a":[]}-AABAADKqAHzC9bQ6VZy9HP5uG7-YhFDJsPGvCYj8BkX3z8GWIpcNdeXE4t7XRXxddn6r19uTxsBs-"#,
926                r#"zN_-41rgzMM68M"#
927            )
928        );
929
930        // Create data attachments
931        let mut data_map1 = IndexMap::new();
932        data_map1.insert(
933            "i".to_string(),
934            SadValue::String("EbAwspDmOlHDUjGZ8m9JGQ4r7Knt5gu4KBNt0JSL2ZoI".to_string()),
935        );
936        data_map1.insert("s".to_string(), SadValue::String("3".to_string()));
937        data_map1.insert(
938            "d".to_string(),
939            SadValue::String("EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs".to_string()),
940        );
941        let data = vec![SadValue::from(SadValue::Object(data_map1))];
942
943        let xserder =
944            InteractEventBuilder::new(serder.pre().unwrap(), rserder.said().unwrap().to_string())
945                .with_sn(2)
946                .with_data_list(data)
947                .build()?;
948
949        // Sign the serialized event
950        let xsigers: Vec<Siger> = manager
951            .sign(
952                xserder.raw(),
953                None,
954                Some(verfers),
955                None,
956                None,
957                None,
958                None,
959                None,
960            )?
961            .iter()
962            .map(|sigmat| match sigmat {
963                Sigmat::Indexed(siger) => siger.clone(),
964                Sigmat::NonIndexed(_) => {
965                    panic!("Unexpected non-indexed signature");
966                }
967            })
968            .collect();
969        let msg = messagize(&xserder, Some(&xsigers), None, None, None, false)?;
970        kel.push_str(&String::from_utf8(msg.clone())?);
971        assert_eq!(
972            String::from_utf8(msg)?,
973            concat!(
974                r#"{"v":"KERI10JSON00013a_","t":"ixn","d":"EMljYBNn3JU_oD8O0_JmQ1Q7w3yFnCON9lauFHnDmNju","#,
975                r#""i":"EPXgQxGLRPBzBR84e6hZ_SY1l5-WJU8b_n8ibASNDfKM","s":"2","p":"EFFvfdKjytGurVS52KzF5"#,
976                r#"NefoQkVJp9w3vDb5is9mEzP","a":[{"i":"EbAwspDmOlHDUjGZ8m9JGQ4r7Knt5gu4KBNt0JSL2ZoI","s":"#,
977                r#""3","d":"EY2L3ycqK9645aEeQKP941xojSiuiHsw4Y6yTW-DpRXs"}]}-AABAAAg0JyLoHFC2vezhTm6jz_"#,
978                r#"BxbmSbSsvqxzeM8sP9fPekAFCKnlH-tsL_0SYmhA5HDXLcmQ4yWa0oWo4w4sYe0sP"#
979            )
980        );
981
982        let (verfers, digers) = manager.rotate(
983            &serder.preb().unwrap(),
984            None,
985            Some(1),
986            None,
987            None,
988            Some(true),
989            Some(false),
990            Some(false),
991        )?;
992        assert_eq!(verfers.len(), 1);
993        assert_eq!(digers.len(), 1);
994        assert_eq!(
995            verfers[0].qb64(),
996            "DNFcsn7EiJemcWD_6bMOdeYUU1j2dC98WCCGjN7PxCIp"
997        );
998        assert_eq!(
999            digers[0].qb64(),
1000            "EAu_UWkr40QDQWScisiLnv5rCJc5unxnAhu33V1RzzpA"
1001        );
1002
1003        let rserder = RotateEventBuilder::new(
1004            serder.pre().unwrap(),
1005            vec![verfers[0].qb64()],
1006            xserder.said().unwrap().to_string(),
1007        )
1008        .with_sn(3)
1009        .with_ndigs(vec![digers[0].qb64()])
1010        .build()?;
1011
1012        // Sign the serialized event
1013        let rsigers: Vec<Siger> = manager
1014            .sign(
1015                rserder.raw(),
1016                None,
1017                Some(verfers),
1018                None,
1019                None,
1020                None,
1021                None,
1022                None,
1023            )?
1024            .iter()
1025            .map(|sigmat| match sigmat {
1026                Sigmat::Indexed(siger) => siger.clone(),
1027                Sigmat::NonIndexed(_) => {
1028                    panic!("Unexpected non-indexed signature");
1029                }
1030            })
1031            .collect();
1032
1033        // Test rotation with messagize with sigers
1034        let msg = messagize(&rserder, Some(&rsigers), None, None, None, false)?;
1035        kel.push_str(&String::from_utf8(msg.clone())?);
1036        assert_eq!(
1037            String::from_utf8(msg)?,
1038            concat!(
1039                r#"{"v":"KERI10JSON000160_","t":"rot","d":"EGC9ReDqCudaBI65eEmn2M52rr3YLb0j1j3PR0SAvSz9","#,
1040                r#""i":"EPXgQxGLRPBzBR84e6hZ_SY1l5-WJU8b_n8ibASNDfKM","s":"3","p":"EMljYBNn3JU_oD8O0_JmQ1Q7"#,
1041                r#"w3yFnCON9lauFHnDmNju","kt":"1","k":["DNFcsn7EiJemcWD_6bMOdeYUU1j2dC98WCCGjN7PxCIp"],"#,
1042                r#""nt":"1","n":["EAu_UWkr40QDQWScisiLnv5rCJc5unxnAhu33V1RzzpA"],"bt":"0","br":[],"ba":[],"#,
1043                r#""a":[]}-AABAACe5_Be6a0cYFts3p5clD7X2RCjkWGQVmKvLjr8ONN9azBqPRQGMj6B7eRwHFQ-AdC98PNA"#,
1044                r#"niDuFv4BGK8GsvoE"#
1045            )
1046        );
1047
1048        println!("{}", kel);
1049
1050        Ok(())
1051    }
1052}
1053
1054/// A weighted threshold (`kt`/`nt`) as an event field: the JSON list of
1055/// fractions, or list of lists for several clauses, as keripy writes it
1056/// (keripy: core/coring.py Tholder.sith), not a string holding that JSON.
1057pub(crate) fn weights_value(
1058    weights: &serde_json::Value,
1059) -> Result<crate::keri::core::serdering::SadValue, crate::keri::KERIError> {
1060    serde_json::from_value(weights.clone())
1061        .map_err(|e| crate::keri::KERIError::ValueError(format!("weighted threshold {}: {}", weights, e)))
1062}