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
37const MAX_INT_THOLD: usize = 12; fn ample(n: usize) -> usize {
41 std::cmp::max(1, (n as f64 / 2.0).ceil() as usize)
43}
44
45fn is_digest_code(code: &str) -> bool {
46 ["E", "S", "X"].contains(&code)
48}
49
50fn is_prefix_code(code: &str) -> bool {
51 ["A", "B", "C", "D"].contains(&code)
53}
54
55#[derive(Debug, Clone)]
57pub struct SealEvent {
58 pub i: String, pub s: String, pub d: String, }
62
63impl SealEvent {
64 pub fn new(i: String, s: String, d: String) -> Self {
65 Self { i, s, d }
66 }
67}
68
69#[derive(Debug, Clone)]
71pub struct SealLast {
72 pub i: String, }
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
86pub fn validate_sigs(
115 serder: &SerderKERI,
116 sigers: Vec<Siger>,
117 verfers: &[Verfer],
118 tholder: &Tholder,
119) -> Result<(Vec<Siger>, bool), KERIError> {
120 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 let (verified_sigers, indices) = verify_sigs(serder.raw(), sigers, verfers)?;
132 if indices.is_empty() {
136 return Err(KERIError::ValidationError(format!(
137 "No verified signatures for message={:?}",
138 serder.ked()
139 )));
140 }
141
142 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(); let mut atc = Vec::new(); 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 if let Some(seal_any) = seal {
167 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 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 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 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 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 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 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 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 atc.extend(cigar.verfer().unwrap().qb64b());
259 atc.extend(cigar.qb64b());
260 }
261 }
262 }
263
264 if pipelined {
265 if atc.len() % 4 != 0 {
267 return Err(format!(
268 "Invalid attachments size={}, nonintegral quadlets.",
269 atc.len()
270 )
271 .into());
272 }
273
274 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 msg.extend(atc);
285
286 Ok(msg)
287}
288
289fn 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 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 let mut usigers_with_verfers = Vec::new();
332
333 for mut siger in unique_sigers {
335 let index = siger.index() as usize;
336 if index >= verfers.len() {
337 continue;
339 }
340
341 let verfer = verfers[index].clone();
343 siger.set_verfer(verfer);
344 usigers_with_verfers.push(siger);
345 }
346
347 let mut vindices = Vec::new();
349 let mut vsigers = Vec::new();
350
351 for siger in usigers_with_verfers {
353 if let Some(verfer) = siger.verfer() {
355 match verfer.verify(siger.raw(), raw) {
357 Ok(true) => {
358 vindices.push(siger.index() as usize);
360 vsigers.push(siger);
361 }
362 Ok(false) => {
363 print!("Signature failed verification for index {}", siger.index());
365 }
366 Err(err) => {
367 print!(
369 "Error verifying signature at index {}: {:?}",
370 siger.index(),
371 err
372 );
373 }
374 }
375 } else {
376 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 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 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 let serder = InceptionEventBuilder::new(vec![verfers[0].qb64()])
438 .with_code(mtr_dex::BLAKE3_256.to_string())
439 .build()?;
440
441 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 let msg = messagize(&serder, Some(&sigers), None, None, None, false)?;
464
465 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 let msg = messagize(&serder, Some(&sigers), None, None, None, true)?;
480
481 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 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 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 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 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 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 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 let msg = messagize(&serder, None, None, Some(&wigers), None, true)?;
598
599 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 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 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 let msg = messagize(&serder, None, None, None, Some(&cigars), true)?;
668
669 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 let msg = messagize(&serder, None, None, Some(&wigers), Some(&cigars), false)?;
685
686 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 let msg = messagize(&serder, None, None, Some(&wigers), Some(&cigars), true)?;
703
704 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 let msg = messagize(
721 &serder,
722 Some(&sigers),
723 None,
724 Some(&wigers),
725 Some(&cigars),
726 false,
727 )?;
728
729 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 let msg = messagize(
747 &serder,
748 Some(&sigers),
749 None,
750 Some(&wigers),
751 Some(&cigars),
752 true,
753 )?;
754
755 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 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 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 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 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 let mut kel = String::new();
849
850 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 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 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 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 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 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 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
1054pub(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}