1use crate::cesr::cigar::Cigar;
2use crate::cesr::counting::{ctr_dex_1_0, BaseCounter, Counter};
3use crate::cesr::dater::Dater;
4use crate::cesr::indexing::siger::Siger;
5use crate::cesr::pather::Pather;
6use crate::cesr::prefixer::Prefixer;
7use crate::cesr::saider::Saider;
8use crate::cesr::seqner::Seqner;
9use crate::cesr::texter::Texter;
10use crate::cesr::verfer::Verfer;
11use crate::cesr::COLDS;
12use crate::cesr::{sniff, Parsable, Versionage, VRSN_1_0};
13use crate::errors::MatterError;
14use crate::keri::core::eventing::Kevery;
15use crate::keri::core::serdering::{Serder, SerderACDC, SerderKERI, Serdery};
16use crate::keri::{Ilk, KERIError};
17use std::sync::{Arc, Mutex};
18use std::time::{Duration, Instant};
19use tokio::io::{AsyncRead, AsyncReadExt};
20
21#[derive(Debug, Clone)]
23pub struct Tsgs {
24 prefixer: Prefixer,
25 seqner: Seqner,
26 saider: Saider,
27 sigers: Vec<Siger>,
28}
29
30#[derive(Debug, Clone)]
31pub struct Trqs {
32 prefixer: Prefixer,
33 seqner: Seqner,
34 saider: Saider,
35 siger: Siger,
36}
37
38#[derive(Debug, Clone)]
39pub struct Trrs {
40 prefixer: Prefixer,
41 seqner: Seqner,
42}
43
44#[derive(Debug, Clone)]
45pub struct Ssgs {
46 prefixer: Prefixer,
47 sigers: Vec<Siger>,
48}
49
50#[derive(Debug, Clone)]
51pub struct Frcs {
52 seqner: Seqner,
53 dater: Dater,
54}
55
56#[derive(Debug, Clone)]
57pub struct Ssts {
58 prefixer: Prefixer,
59 seqner: Seqner,
60 saider: Saider,
61}
62
63#[derive(Debug, Clone)]
64pub struct Sscs {
65 seqner: Seqner,
66 saider: Saider,
67}
68
69#[derive(Debug, Clone)]
71pub struct SadTsgs {
72 path: Pather,
73 prefixer: Prefixer,
74 seqner: Seqner,
75 saider: Saider,
76 sigers: Vec<Siger>,
77}
78
79#[derive(Debug, Clone)]
80pub struct SadSigers {
81 path: Pather,
82 sigers: Vec<Siger>,
83}
84
85#[derive(Debug, Clone)]
86pub struct SadCigars {
87 path: Pather,
88 cigar: Cigar,
89}
90
91pub enum SadPathGroup {
93 TransIdxSig(SadTsgs),
94 ControllerIdxSig(SadSigers),
95 NonTransReceipt(SadCigars),
96}
97
98pub enum Message {
101 KeyEvent {
103 serder: Box<SerderKERI>,
104 sigers: Option<Vec<Siger>>,
105 wigers: Option<Vec<Siger>>,
106 delseqner: Option<Seqner>,
107 delsaider: Option<Saider>,
108 firner: Option<Seqner>,
109 dater: Option<Dater>,
110 cigars: Option<Vec<Cigar>>, trqs: Option<Vec<Trqs>>, local: Option<bool>,
113 },
114
115 Receipt {
117 serder: Box<SerderKERI>,
118 cigars: Vec<Cigar>,
119 local: Option<bool>,
120 },
121
122 WitnessReceipt {
124 serder: Box<SerderKERI>,
125 wigers: Vec<Siger>,
126 local: Option<bool>,
127 },
128
129 ReceiptTrans {
131 serder: Box<dyn Serder>,
132 tsgs: Vec<Tsgs>,
133 local: Option<bool>,
134 },
135
136 Query {
138 serder: Box<SerderKERI>,
139 source: Option<Prefixer>,
140 sigers: Option<Vec<Siger>>,
141 cigar: Option<Vec<Cigar>>,
142 },
143
144 ReplyNonTrans {
146 serder: Box<dyn Serder>,
147 cigars: Vec<Cigar>,
148 },
149
150 ReplyTrans {
152 serder: Box<dyn Serder>,
153 tsgs: Vec<Tsgs>,
154 },
155
156 ExchangeEventNonTrans {
158 serder: Box<dyn Serder>,
159 cigars: Vec<Cigar>,
160 pathed: Option<Vec<Vec<u8>>>,
161 essrs: Option<Vec<Texter>>,
162 },
163
164 ExchangeEventTrans {
166 serder: Box<dyn Serder>,
167 tsgs: Vec<Tsgs>,
168 pathed: Option<Vec<Vec<u8>>>,
169 essrs: Option<Vec<Texter>>,
170 },
171
172 TELEvent {
174 serder: Box<dyn Serder>,
175 seqner: Option<Seqner>,
176 saider: Option<Saider>,
177 wigers: Option<Vec<Siger>>,
178 },
179
180 Credential {
182 creder: Box<dyn Serder>,
183 prefixer: Option<Prefixer>,
184 seqner: Option<Seqner>,
185 saider: Option<Saider>,
186 },
187}
188
189impl Message {
191 pub fn is_local(&self) -> bool {
193 match self {
194 Message::KeyEvent { local, .. } => local.unwrap_or(false),
195 Message::Receipt { local, .. } => local.unwrap_or(false),
196 Message::WitnessReceipt { local, .. } => local.unwrap_or(false),
197 Message::ReceiptTrans { local, .. } => local.unwrap_or(false),
198 _ => false,
199 }
200 }
201}
202#[async_trait::async_trait]
204pub trait MessageHandler: Send + Sync {
205 fn handle(
206 &self,
207 msg: Message,
208 ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), KERIError>> + Send + '_>>;
209}
210
211pub struct Parser<R> {
212 reader: R,
213 buffer: Vec<u8>,
214 framed: bool,
215 pipeline: bool,
216 handlers: Option<Handlers>,
217 local: bool,
219 attachment_processing: bool, current_serder: Option<Box<dyn Serder>>,
221 serdery: Serdery,
222}
223pub struct Handlers {
224 pub kevery: Arc<Mutex<Kevery>>,
225 pub tevery: Arc<dyn MessageHandler>,
226 pub exchanger: Arc<dyn MessageHandler>,
227 pub revery: Arc<dyn MessageHandler>,
228 pub verifier: Arc<dyn MessageHandler>,
229 pub local: bool,
230}
231
232impl<R> Parser<R> {
233 pub fn parse_one(&mut self, ims: &[u8]) -> Result<(), KERIError> {
236 let mut temp_buffer = ims.to_vec();
238
239 let original_buffer = std::mem::replace(&mut self.buffer, temp_buffer);
241
242 let result = self.try_parse_one_message();
244
245 self.buffer = original_buffer;
247
248 result
249 }
250
251 fn try_parse_one_message(&mut self) -> Result<(), KERIError> {
253 match self.try_parse_message() {
255 Ok((message, _consumed)) => {
256 self.attachment_processing = false;
258 self.current_serder = None;
259
260 self.process_parsed_message(message)?;
262
263 Ok(())
264 }
265 Err(MatterError::NeedMoreDataError(_)) => {
266 Err(KERIError::Parsing(
268 "Incomplete message in parseOne".to_string(),
269 ))
270 }
271 Err(e) => Err(KERIError::Parsing(format!(
272 "Failed to parse message: {}",
273 e
274 ))),
275 }
276 }
277
278 fn process_parsed_message(&mut self, message: Message) -> Result<(), KERIError> {
280 match message {
281 Message::KeyEvent {
282 serder,
283 sigers,
284 wigers,
285 cigars,
286 ..
287 } => {
288 let mut kevery_guard = self.handlers()?.kevery.lock().unwrap();
290 let result = kevery_guard.process_event(
291 *serder,
292 sigers.unwrap_or_default(),
293 wigers,
294 None, None, None, None, None, None, );
301
302 match result {
304 Ok(_) => {}
305 Err(KERIError::MissingSignatureError(_)) => {
306 }
308 Err(e) => return Err(e),
309 }
310 Ok(())
311 }
312 Message::Receipt { serder, cigars, .. } => {
313 let mut kevery_guard = self.handlers()?.kevery.lock().unwrap();
315 kevery_guard.process_receipt(*serder, cigars, None)?;
316 Ok(())
317 }
318 Message::WitnessReceipt { serder, wigers, .. } => {
319 let mut kevery_guard = self.handlers()?.kevery.lock().unwrap();
321 kevery_guard.process_receipt_witness(*serder, wigers, None)?;
322 Ok(())
323 }
324 Message::Query {
325 serder,
326 source,
327 sigers,
328 cigar,
329 } => {
330 let mut kevery_guard = self.handlers()?.kevery.lock().unwrap();
332 kevery_guard.process_query(*serder, source, sigers, cigar)?;
333 Ok(())
334 }
335 Message::ReplyNonTrans { serder, cigars } => {
336 let msg = Message::ReplyNonTrans { serder, cigars };
338 futures::executor::block_on(self.handlers()?.revery.handle(msg))?;
339 Ok(())
340 }
341 Message::ReplyTrans { serder, tsgs } => {
342 let msg = Message::ReplyTrans { serder, tsgs };
344 futures::executor::block_on(self.handlers()?.revery.handle(msg))?;
345 Ok(())
346 }
347 _ => {
348 Ok(())
350 }
351 }
352 }
353
354 fn try_parse_message(&mut self) -> Result<(Message, usize), MatterError> {
355 let processing_attachments = self.attachment_processing && self.buffer.get(0) == Some(&45);
357
358 if !self.buffer.is_empty() && self.buffer[0] == 45 && !self.attachment_processing {
361 let json_pattern = b"{\"v\":";
362 let mut next_msg_pos = None;
363
364 for i in 0..(self.buffer.len().saturating_sub(json_pattern.len())) {
365 if &self.buffer[i..i + json_pattern.len()] == json_pattern {
366 next_msg_pos = Some(i);
367 break;
368 }
369 }
370
371 if let Some(pos) = next_msg_pos {
372 self.buffer.drain(..pos);
373 } else {
374 return Err(MatterError::NeedMoreDataError(
375 "No complete message found after attachment".to_string(),
376 ));
377 }
378 }
379
380 if self.attachment_processing {
382 if self.current_serder.is_none() {
384 self.attachment_processing = false;
386
387 if !self.buffer.is_empty() && self.buffer[0] == 45 {
389 let json_pattern = b"{\"v\":";
390 let mut next_msg_pos = None;
391
392 for i in 0..(self.buffer.len().saturating_sub(json_pattern.len())) {
393 if &self.buffer[i..i + json_pattern.len()] == json_pattern {
394 next_msg_pos = Some(i);
395 break;
396 }
397 }
398
399 if let Some(pos) = next_msg_pos {
400 self.buffer.drain(..pos);
401 }
402 }
403 } else {
404 let serder = self.current_serder.take().unwrap();
407
408 let mut sigers: Vec<Siger> = Vec::new();
410 let mut wigers: Vec<Siger> = Vec::new();
411 let mut cigars: Vec<Cigar> = Vec::new();
412 let mut trqs: Vec<Trqs> = Vec::new();
413 let mut tsgs: Vec<Tsgs> = Vec::new();
414 let mut ssgs: Vec<Ssgs> = Vec::new();
415 let mut frcs: Vec<Frcs> = Vec::new();
416 let mut sscs: Vec<Sscs> = Vec::new();
417 let mut ssts: Vec<Ssts> = Vec::new();
418 let mut sadtsgs: Vec<SadTsgs> = Vec::new();
419 let mut sadsigs: Vec<SadSigers> = Vec::new();
420 let mut sadcigs: Vec<SadCigars> = Vec::new();
421 let mut pathed: Vec<Vec<u8>> = Vec::new();
422 let mut essrs: Vec<Texter> = Vec::new();
423
424 let buffer_before_attachments = self.buffer.len();
426
427 while !self.buffer.is_empty() {
429 if self.buffer[0] == 123 {
430 break;
433 } else if self.buffer[0] == 45 {
434 match sniff(self.buffer.as_slice()) {
437 Ok(cold) => {
438 if cold != COLDS.msg {
439 let mut pipelined = false;
440
441 match self._extractor::<BaseCounter>(cold, false, &VRSN_1_0) {
442 Ok(ctr) => {
443 if ctr.code() == ctr_dex_1_0::ATTACHMENT_GROUP {
444 pipelined = true;
445
446 let pags = if cold == COLDS.txt {
448 ctr.count() * 4
449 } else {
450 ctr.count() * 3
451 };
452
453 if self.buffer.len() < pags as usize {
454 self.current_serder = Some(serder);
457 self.attachment_processing = true;
458
459 return Err(MatterError::NeedMoreDataError(
460 "Not enough data for attachments"
461 .to_string(),
462 ));
463 }
464
465 match self._extractor::<BaseCounter>(
466 cold, pipelined, &VRSN_1_0,
467 ) {
468 Ok(extracted_ctr) => {
469 self.process_attachments(
470 &extracted_ctr,
471 cold,
472 pipelined,
473 &mut sigers,
474 &mut wigers,
475 &mut cigars,
476 &mut trqs,
477 &mut tsgs,
478 &mut ssgs,
479 &mut frcs,
480 &mut sscs,
481 &mut ssts,
482 &mut sadtsgs,
483 &mut sadsigs,
484 &mut sadcigs,
485 &mut pathed,
486 &mut essrs,
487 )?;
488 }
489 Err(e) => return Err(e),
490 }
491 } else {
492 let mut current_ctr = ctr;
494 let mut current_cold = cold;
495
496 loop {
497 self.process_attachments(
498 ¤t_ctr,
499 current_cold,
500 pipelined,
501 &mut sigers,
502 &mut wigers,
503 &mut cigars,
504 &mut trqs,
505 &mut tsgs,
506 &mut ssgs,
507 &mut frcs,
508 &mut sscs,
509 &mut ssts,
510 &mut sadtsgs,
511 &mut sadsigs,
512 &mut sadcigs,
513 &mut pathed,
514 &mut essrs,
515 )?;
516
517 if self.buffer.is_empty() {
519 break;
520 }
521
522 if self.buffer[0] == 123 {
524 break;
525 }
526
527 let new_cold = match sniff(&self.buffer) {
529 Ok(c) => c,
530 Err(e) => break,
531 };
532
533 if new_cold == COLDS.msg {
535 break;
536 }
537
538 current_cold = new_cold;
539
540 match self._extractor::<BaseCounter>(
542 current_cold,
543 false,
544 &VRSN_1_0,
545 ) {
546 Ok(next_ctr) => {
547 current_ctr = next_ctr;
548 }
549 Err(_) => break,
550 }
551 }
552 }
553 }
554 Err(e) => return Err(e),
555 }
556 } else {
557 break;
559 }
560 }
561 Err(e) => return Err(e),
562 }
563 } else {
564 return Err(MatterError::ParseError(
566 "Unexpected data format".to_string(),
567 ));
568 }
569 }
570
571 let attachment_size = buffer_before_attachments - self.buffer.len();
573
574 let msg = self.process_message(
576 serder,
577 sigers,
578 wigers,
579 cigars,
580 trqs,
581 tsgs,
582 ssgs,
583 sscs,
584 frcs,
585 ssts,
586 pathed,
587 sadtsgs,
588 sadcigs,
589 essrs,
590 self.local,
591 )?;
592
593 self.attachment_processing = false;
595
596 return Ok((msg, attachment_size));
597 }
598 }
599
600 let serder = self
602 .serdery
603 .reap(self.buffer.as_slice(), "-AAAA", &VRSN_1_0, None, None)
604 .map_err(|e| {
605 let error_message = format!("{:?}", e);
606
607 if error_message.contains("EOF while parsing")
608 || error_message.contains("unexpected end of input")
609 || error_message.contains("JsonError")
610 {
611 return MatterError::NeedMoreDataError(format!(
612 "Incomplete JSON message: {}",
613 error_message
614 ));
615 }
616
617 MatterError::EncodingError("Invalid UTF-8 in count chars".to_string())
618 })?;
619
620 let serder_size = serder.size();
621 self.buffer.drain(..serder_size);
622
623 let mut sigers: Vec<Siger> = Vec::new();
625 let mut wigers: Vec<Siger> = Vec::new();
626 let mut cigars: Vec<Cigar> = Vec::new();
627 let mut trqs: Vec<Trqs> = Vec::new();
628 let mut tsgs: Vec<Tsgs> = Vec::new();
629 let mut ssgs: Vec<Ssgs> = Vec::new();
630 let mut frcs: Vec<Frcs> = Vec::new();
631 let mut sscs: Vec<Sscs> = Vec::new();
632 let mut ssts: Vec<Ssts> = Vec::new();
633 let mut sadtsgs: Vec<SadTsgs> = Vec::new();
634 let mut sadsigs: Vec<SadSigers> = Vec::new();
635 let mut sadcigs: Vec<SadCigars> = Vec::new();
636 let mut pathed: Vec<Vec<u8>> = Vec::new();
637 let mut essrs: Vec<Texter> = Vec::new();
638
639 let mut attachment_size = 0;
641 let buffer_before_attachments = self.buffer.len();
642
643 while !self.buffer.is_empty() {
645 if self.buffer[0] == 123 {
646 break;
649 } else if self.buffer[0] == 45 {
650 match sniff(self.buffer.as_slice()) {
653 Ok(cold) => {
654 if cold != COLDS.msg {
655 let mut pipelined = false;
656
657 match self._extractor::<BaseCounter>(cold, false, &VRSN_1_0) {
658 Ok(ctr) => {
659 if ctr.code() == ctr_dex_1_0::ATTACHMENT_GROUP {
660 pipelined = true;
661
662 let pags = if cold == COLDS.txt {
664 ctr.count() * 4
665 } else {
666 ctr.count() * 3
667 };
668
669 if self.buffer.len() < pags as usize {
670 self.current_serder = Some(serder.clone_box());
673 self.attachment_processing = true;
674
675 return Err(MatterError::NeedMoreDataError(
676 "Not enough data for attachments".to_string(),
677 ));
678 }
679
680 match self
681 ._extractor::<BaseCounter>(cold, pipelined, &VRSN_1_0)
682 {
683 Ok(extracted_ctr) => {
684 self.process_attachments(
685 &extracted_ctr,
686 cold,
687 pipelined,
688 &mut sigers,
689 &mut wigers,
690 &mut cigars,
691 &mut trqs,
692 &mut tsgs,
693 &mut ssgs,
694 &mut frcs,
695 &mut sscs,
696 &mut ssts,
697 &mut sadtsgs,
698 &mut sadsigs,
699 &mut sadcigs,
700 &mut pathed,
701 &mut essrs,
702 )?;
703 }
704 Err(e) => return Err(e),
705 }
706 } else {
707 let mut current_ctr = ctr;
709 let mut current_cold = cold;
710
711 loop {
712 self.process_attachments(
713 ¤t_ctr,
714 current_cold,
715 pipelined,
716 &mut sigers,
717 &mut wigers,
718 &mut cigars,
719 &mut trqs,
720 &mut tsgs,
721 &mut ssgs,
722 &mut frcs,
723 &mut sscs,
724 &mut ssts,
725 &mut sadtsgs,
726 &mut sadsigs,
727 &mut sadcigs,
728 &mut pathed,
729 &mut essrs,
730 )?;
731
732 if self.buffer.is_empty() {
734 break;
735 }
736
737 if self.buffer[0] == 123 {
739 break;
740 }
741
742 let new_cold = match sniff(&self.buffer) {
744 Ok(c) => c,
745 Err(_) => break,
746 };
747
748 if new_cold == COLDS.msg {
750 break;
751 }
752
753 current_cold = new_cold;
754
755 match self._extractor::<BaseCounter>(
757 current_cold,
758 false,
759 &VRSN_1_0,
760 ) {
761 Ok(next_ctr) => {
762 current_ctr = next_ctr;
763 }
764 Err(_) => break,
765 }
766 }
767 }
768 }
769 Err(e) => return Err(e),
770 }
771 } else {
772 break;
774 }
775 }
776 Err(e) => return Err(e),
777 }
778 } else {
779 return Err(MatterError::ParseError(
781 "Unexpected data format".to_string(),
782 ));
783 }
784 }
785
786 attachment_size = buffer_before_attachments - self.buffer.len();
788
789 let msg = self.process_message(
791 serder,
792 sigers,
793 wigers,
794 cigars,
795 trqs,
796 tsgs,
797 ssgs,
798 sscs,
799 frcs,
800 ssts,
801 pathed,
802 sadtsgs,
803 sadcigs,
804 essrs,
805 self.local,
806 )?;
807
808 let total_processed = serder_size + attachment_size;
809
810 Ok((msg, total_processed))
811 }
812 pub fn new(reader: R, framed: bool, pipeline: bool, handlers: Handlers) -> Self {
813 let local = handlers.local;
814 Self {
815 reader,
816 buffer: Vec::new(),
817 framed,
818 pipeline,
819 handlers: Some(handlers),
820 local,
821 attachment_processing: true,
822 current_serder: None,
823 serdery: Serdery::new(),
824 }
825 }
826
827 pub fn without_handlers(reader: R, framed: bool, pipeline: bool, local: bool) -> Self {
832 Self {
833 reader,
834 buffer: Vec::new(),
835 framed,
836 pipeline,
837 handlers: None,
838 local,
839 attachment_processing: true,
840 current_serder: None,
841 serdery: Serdery::new(),
842 }
843 }
844
845 fn handlers(&self) -> Result<&Handlers, KERIError> {
846 self.handlers.as_ref().ok_or_else(|| {
847 KERIError::ConfigurationError(
848 "Parser has no handlers; use parse_messages and route the results".to_string(),
849 )
850 })
851 }
852
853 pub fn parse_messages(&mut self, ims: &[u8]) -> Result<Vec<Message>, KERIError> {
856 let original_buffer = std::mem::replace(&mut self.buffer, ims.to_vec());
857 let mut msgs = Vec::new();
858 let result = loop {
859 if self.buffer.is_empty() {
860 break Ok(());
861 }
862 if self.current_serder.is_none() {
864 self.attachment_processing = false;
865 }
866 match self.try_parse_message() {
867 Ok((message, _consumed)) => {
868 self.attachment_processing = false;
870 self.current_serder = None;
871 msgs.push(message);
872 }
873 Err(MatterError::NeedMoreDataError(_)) => {
874 break Err(KERIError::Parsing(
875 "Incomplete message in parse_messages".to_string(),
876 ))
877 }
878 Err(e) => break Err(KERIError::Parsing(format!("Failed to parse message: {}", e))),
879 }
880 };
881 self.buffer = original_buffer;
882 result.map(|_| msgs)
883 }
884
885 fn process_attachments(
887 &mut self,
888 ctr: &BaseCounter,
889 cold: &str,
890 pipelined: bool,
891 sigers: &mut Vec<Siger>,
892 wigers: &mut Vec<Siger>,
893 cigars: &mut Vec<Cigar>,
894 trqs: &mut Vec<Trqs>,
895 tsgs: &mut Vec<Tsgs>,
896 ssgs: &mut Vec<Ssgs>,
897 frcs: &mut Vec<Frcs>,
898 sscs: &mut Vec<Sscs>,
899 ssts: &mut Vec<Ssts>,
900 sadtsgs: &mut Vec<SadTsgs>,
901 sadsigs: &mut Vec<SadSigers>,
902 sadcigs: &mut Vec<SadCigars>,
903 pathed: &mut Vec<Vec<u8>>,
904 essrs: &mut Vec<Texter>,
905 ) -> Result<(), MatterError> {
906 match ctr.code() {
907 ctr_dex_1_0::CONTROLLER_IDX_SIGS => {
908 for _ in 0..ctr.count() {
909 match self._extractor::<Siger>(cold, pipelined, &VRSN_1_0) {
910 Ok(siger) => sigers.push(siger),
911 Err(e) => return Err(e),
912 }
913 }
914 }
915
916 ctr_dex_1_0::WITNESS_IDX_SIGS => {
917 for _ in 0..ctr.count() {
918 match self._extractor::<Siger>(cold, pipelined, &VRSN_1_0) {
919 Ok(wiger) => wigers.push(wiger),
920 Err(e) => return Err(e),
921 }
922 }
923 }
924
925 ctr_dex_1_0::NON_TRANS_RECEIPT_COUPLES => {
926 match self.non_trans_receipt_couples(ctr, cold, pipelined, &VRSN_1_0) {
928 Ok(extracted_cigars) => cigars.extend(extracted_cigars),
929 Err(e) => return Err(e),
930 }
931 }
932
933 ctr_dex_1_0::NON_TRANS_RECEIPT_COUPLES => {
934 for _ in 0..ctr.count() {
935 let prefixer = match self._extractor::<Prefixer>(cold, pipelined, &VRSN_1_0) {
937 Ok(p) => p,
938 Err(e) => return Err(e),
939 };
940
941 let seqner = match self._extractor::<Seqner>(cold, pipelined, &VRSN_1_0) {
942 Ok(s) => s,
943 Err(e) => return Err(e),
944 };
945
946 let saider = match self._extractor::<Saider>(cold, pipelined, &VRSN_1_0) {
947 Ok(s) => s,
948 Err(e) => return Err(e),
949 };
950
951 let siger = match self._extractor::<Siger>(cold, pipelined, &VRSN_1_0) {
952 Ok(s) => s,
953 Err(e) => return Err(e),
954 };
955
956 trqs.push(Trqs {
957 prefixer,
958 seqner,
959 saider,
960 siger,
961 });
962 }
963 }
964
965 ctr_dex_1_0::TRANS_IDX_SIG_GROUPS => {
966 match self.trans_idx_sig_groups(ctr, cold, pipelined, &VRSN_1_0) {
967 Ok(extracted_tsgs) => tsgs.extend(extracted_tsgs),
968 Err(e) => return Err(e),
969 }
970 }
971
972 ctr_dex_1_0::TRANS_LAST_IDX_SIG_GROUPS => {
973 for _ in 0..ctr.count() {
974 let prefixer = match self._extractor::<Prefixer>(cold, pipelined, &VRSN_1_0) {
975 Ok(p) => p,
976 Err(e) => return Err(e),
977 };
978
979 let ictr = match self._extractor::<BaseCounter>(cold, pipelined, &VRSN_1_0) {
980 Ok(c) => c,
981 Err(e) => return Err(e),
982 };
983
984 if ictr.code() != ctr_dex_1_0::CONTROLLER_IDX_SIGS {
985 return Err(MatterError::UnexpectedCountCodeError(format!(
986 "Wrong count code={}. Expected code={}.",
987 ictr.code(),
988 ctr_dex_1_0::CONTROLLER_IDX_SIGS
989 )));
990 }
991
992 let mut isigers = Vec::new();
993 for _ in 0..ictr.count() {
994 match self._extractor::<Siger>(cold, pipelined, &VRSN_1_0) {
995 Ok(isiger) => isigers.push(isiger),
996 Err(e) => return Err(e),
997 }
998 }
999
1000 ssgs.push(Ssgs {
1001 prefixer,
1002 sigers: isigers,
1003 });
1004 }
1005 }
1006
1007 ctr_dex_1_0::FIRST_SEEN_REPLAY_COUPLES => {
1008 for _ in 0..ctr.count() {
1009 let firner = match self._extractor::<Seqner>(cold, pipelined, &VRSN_1_0) {
1010 Ok(f) => f,
1011 Err(e) => return Err(e),
1012 };
1013
1014 let dater = match self._extractor::<Dater>(cold, pipelined, &VRSN_1_0) {
1015 Ok(d) => d,
1016 Err(e) => return Err(e),
1017 };
1018
1019 frcs.push(Frcs {
1020 seqner: firner,
1021 dater,
1022 });
1023 }
1024 }
1025
1026 ctr_dex_1_0::SEAL_SOURCE_COUPLES => {
1027 for _ in 0..ctr.count() {
1028 let seqner = match self._extractor::<Seqner>(cold, pipelined, &VRSN_1_0) {
1029 Ok(s) => s,
1030 Err(e) => return Err(e),
1031 };
1032
1033 let saider = match self._extractor::<Saider>(cold, pipelined, &VRSN_1_0) {
1034 Ok(s) => s,
1035 Err(e) => return Err(e),
1036 };
1037
1038 sscs.push(Sscs { seqner, saider });
1039 }
1040 }
1041
1042 ctr_dex_1_0::SEAL_SOURCE_TRIPLES => {
1043 for _ in 0..ctr.count() {
1044 let prefixer = match self._extractor::<Prefixer>(cold, pipelined, &VRSN_1_0) {
1045 Ok(p) => p,
1046 Err(e) => return Err(e),
1047 };
1048
1049 let seqner = match self._extractor::<Seqner>(cold, pipelined, &VRSN_1_0) {
1050 Ok(s) => s,
1051 Err(e) => return Err(e),
1052 };
1053
1054 let saider = match self._extractor::<Saider>(cold, pipelined, &VRSN_1_0) {
1055 Ok(s) => s,
1056 Err(e) => return Err(e),
1057 };
1058
1059 ssts.push(Ssts {
1060 prefixer,
1061 seqner,
1062 saider,
1063 });
1064 }
1065 }
1066
1067 ctr_dex_1_0::SAD_PATH_SIG_GROUPS => {
1068 let path = match self._extractor::<Pather>(cold, pipelined, &VRSN_1_0) {
1069 Ok(p) => p,
1070 Err(e) => return Err(e),
1071 };
1072
1073 for _ in 0..ctr.count() {
1074 let ictr = match self._extractor::<BaseCounter>(cold, pipelined, &VRSN_1_0) {
1075 Ok(c) => c,
1076 Err(e) => return Err(e),
1077 };
1078
1079 match self.sad_path_sig_group(&ictr, Some(&path), cold, pipelined, &VRSN_1_0) {
1080 Ok(groups) => {
1081 for group in groups {
1082 match group {
1083 SadPathGroup::TransIdxSig(sadtsg) => {
1084 sadtsgs.push(sadtsg);
1085 }
1086 SadPathGroup::ControllerIdxSig(sadsiger) => {
1087 sadsigs.push(sadsiger);
1088 }
1089 SadPathGroup::NonTransReceipt(sadcigar) => {
1090 sadcigs.push(sadcigar);
1091 }
1092 }
1093 }
1094 }
1095 Err(e) => return Err(e),
1096 }
1097 }
1098 }
1099
1100 ctr_dex_1_0::PATHED_MATERIAL_GROUP | ctr_dex_1_0::BIG_PATHED_MATERIAL_GROUP => {
1101 let pags = if cold == COLDS.txt {
1103 ctr.count() * 4
1104 } else {
1105 ctr.count() * 3
1106 };
1107
1108 if self.buffer.len() < pags as usize {
1110 return Err(MatterError::NeedMoreDataError(
1111 "Needs more data".to_string(),
1112 ));
1113 }
1114
1115 let pims: Vec<u8> = self.buffer.drain(0..pags as usize).collect();
1117 pathed.push(pims);
1118 }
1119
1120 ctr_dex_1_0::ESSR_PAYLOAD_GROUP => {
1121 for _ in 0..ctr.count() {
1122 match self._extractor::<Texter>(cold, pipelined, &VRSN_1_0) {
1123 Ok(texter) => essrs.push(texter),
1124 Err(e) => return Err(e),
1125 }
1126 }
1127 }
1128
1129 _ => {
1130 return Err(MatterError::UnexpectedCountCodeError(format!(
1131 "Unsupported count code={}.",
1132 ctr.code()
1133 )));
1134 }
1135 }
1136
1137 Ok(())
1138 }
1139
1140 async fn dispatch_message(&mut self, msg: Message) -> Result<(), KERIError> {
1141 match msg {
1143 Message::KeyEvent {
1144 serder,
1145 sigers,
1146 wigers,
1147 delseqner,
1148 delsaider,
1149 firner,
1150 dater,
1151 cigars,
1152 trqs,
1153 local,
1154 } => {
1155 let sigs = sigers.unwrap_or_default();
1156 self.handlers()?.kevery.lock().unwrap().process_event(
1157 *serder.clone(),
1158 sigs,
1159 wigers,
1160 delseqner,
1161 delsaider,
1162 firner.clone(),
1163 dater,
1164 Some(false),
1165 local,
1166 )?;
1167
1168 if cigars.is_some() {
1169 self.handlers()?
1170 .kevery
1171 .lock()
1172 .unwrap()
1173 .process_attached_receipt_couples(
1174 *serder.clone(),
1175 firner.clone(),
1176 cigars.unwrap(),
1177 )?;
1178 }
1179
1180 if trqs.is_some() {
1181 self.handlers()?
1182 .kevery
1183 .lock()
1184 .unwrap()
1185 .process_attached_receipt_quadruples(
1186 *serder,
1187 trqs.unwrap(),
1188 firner,
1189 local,
1190 )?;
1191 }
1192 }
1193 Message::Receipt {
1194 serder,
1195 cigars,
1196 local,
1197 } => {
1198 self.handlers()?
1199 .kevery
1200 .lock()
1201 .unwrap()
1202 .process_receipt(*serder, cigars, local)?;
1203 }
1204 Message::WitnessReceipt {
1205 serder,
1206 wigers,
1207 local,
1208 } => {
1209 self.handlers()?
1210 .kevery
1211 .lock()
1212 .unwrap()
1213 .process_receipt_witness(*serder, wigers, local)?;
1214 }
1215 Message::ReceiptTrans {
1216 serder: _,
1217 tsgs: _,
1218 local: _,
1219 } => {}
1220 Message::Query {
1221 serder,
1222 source,
1223 sigers,
1224 cigar,
1225 } => {
1226 let ked = serder.ked();
1227 let route = ked["r"].as_str();
1228 match route {
1229 Some(route) => match route {
1230 "logs" | "ksn" | "mbx" => {
1231 self.handlers()?
1232 .kevery
1233 .lock()
1234 .unwrap()
1235 .process_query(*serder, source, sigers, cigar)?;
1236 }
1237 "tels" | "tsn" => {} &_ => {}
1239 },
1240 None => {}
1241 }
1242 }
1243 Message::ReplyNonTrans {
1244 serder: _,
1245 cigars: _,
1246 } => self.handlers()?.revery.handle(msg).await?,
1247 Message::ReplyTrans { serder: _, tsgs: _ } => self.handlers()?.revery.handle(msg).await?,
1248 Message::ExchangeEventNonTrans {
1249 serder: _,
1250 cigars: _,
1251 pathed: _,
1252 essrs: _,
1253 } => self.handlers()?.exchanger.handle(msg).await?,
1254 Message::ExchangeEventTrans {
1255 serder: _,
1256 tsgs: _,
1257 pathed: _,
1258 essrs: _,
1259 } => self.handlers()?.exchanger.handle(msg).await?,
1260 Message::TELEvent {
1261 serder: _,
1262 seqner: _,
1263 saider: _,
1264 wigers: _,
1265 } => self.handlers()?.tevery.handle(msg).await?,
1266 Message::Credential {
1267 creder: _,
1268 prefixer: _,
1269 seqner: _,
1270 saider: _,
1271 } => self.handlers()?.verifier.handle(msg).await?,
1272 }
1273 Ok(())
1274 }
1275
1276 fn process_message(
1278 &self,
1279 serder: Box<dyn Serder>,
1280 sigers: Vec<Siger>,
1281 wigers: Vec<Siger>,
1282 cigars: Vec<Cigar>,
1283 trqs: Vec<Trqs>,
1284 tsgs: Vec<Tsgs>,
1285 ssgs: Vec<Ssgs>,
1286 sscs: Vec<Sscs>,
1287 frcs: Vec<Frcs>,
1288 ssts: Vec<Ssts>,
1289 pathed: Vec<Vec<u8>>,
1290 _sadtsgs: Vec<SadTsgs>,
1291 _sadcigars: Vec<SadCigars>,
1292 essrs: Vec<Texter>,
1293 local: bool,
1294 ) -> Result<Message, MatterError> {
1295 if let Some(keri_serder) = serder.as_any().downcast_ref::<SerderKERI>() {
1297 let ilk = keri_serder.ilk();
1298
1299 if ilk == Some(Ilk::Icp)
1301 || ilk == Some(Ilk::Rot)
1302 || ilk == Some(Ilk::Ixn)
1303 || ilk == Some(Ilk::Dip)
1304 || ilk == Some(Ilk::Drt)
1305 {
1306 let (firner, dater) = frcs
1308 .last()
1309 .map(|frcs| (Some(frcs.seqner.clone()), Some(frcs.dater.clone())))
1310 .unwrap_or((None, None));
1311
1312 let (delseqner, delsaider) = sscs
1314 .last()
1315 .map(|sscs| (Some(sscs.seqner.clone()), Some(sscs.saider.clone())))
1316 .unwrap_or((None, None));
1317
1318 if sigers.is_empty() {
1320 let sad = keri_serder.sad();
1321 let d = sad["d"].as_str().unwrap();
1322 let msg = format!("Missing attached signature(s) for evt = {}", d);
1323 tracing::info!("{}", msg);
1324 tracing::debug!("Event Body = \n{}\n", keri_serder.pretty(None));
1325 return Err(MatterError::ValidationError(msg));
1326 }
1327
1328 let message = Message::KeyEvent {
1330 serder: Box::new(keri_serder.clone()),
1331 sigers: Some(sigers),
1332 wigers: if wigers.is_empty() {
1333 None
1334 } else {
1335 Some(wigers)
1336 },
1337 delseqner,
1338 delsaider,
1339 firner,
1340 dater,
1341 cigars: Some(cigars),
1342 trqs: Some(trqs),
1343 local: Some(local),
1344 };
1345
1346 return Ok(message);
1347 }
1348 else if ilk == Some(Ilk::Rct) {
1350 if cigars.is_empty() && wigers.is_empty() && tsgs.is_empty() {
1351 let msg = format!(
1352 "Missing attached signatures on receipt msg sn={} SAID={}",
1353 keri_serder.sn().unwrap(),
1354 keri_serder.said().unwrap()
1355 );
1356 tracing::info!("{}", msg);
1357 tracing::debug!("Receipt body=\n{}\n", keri_serder.pretty(None));
1358 return Err(MatterError::ValidationError(msg));
1359 }
1360
1361 if !cigars.is_empty() {
1362 return Ok(Message::Receipt {
1363 serder: Box::new(keri_serder.clone()),
1364 cigars,
1365 local: Some(local),
1366 });
1367 }
1368
1369 if !wigers.is_empty() {
1370 return Ok(Message::WitnessReceipt {
1371 serder: Box::new(keri_serder.clone()),
1372 wigers,
1373 local: Some(local),
1374 });
1375 }
1376
1377 if !tsgs.is_empty() {
1378 return Ok(Message::ReceiptTrans {
1379 serder,
1380 tsgs,
1381 local: Some(local),
1382 });
1383 }
1384 }
1385 else if ilk == Some(Ilk::Rpy) {
1387 if cigars.is_empty() && tsgs.is_empty() {
1388 let msg = format!(
1389 "Missing attached endorser signature(s) to reply msg = {}",
1390 keri_serder.pretty(None)
1391 );
1392 return Err(MatterError::ValidationError(msg));
1393 }
1394
1395 if !cigars.is_empty() {
1396 return Ok(Message::ReplyNonTrans { serder, cigars });
1397 }
1398
1399 if !tsgs.is_empty() {
1400 return Ok(Message::ReplyTrans { serder, tsgs });
1401 }
1402 }
1403 else if ilk == Some(Ilk::Qry) {
1405 return if !sscs.is_empty() {
1407 let ssgs = ssgs.last().unwrap();
1408
1409 Ok(Message::Query {
1410 serder: Box::new(keri_serder.clone()),
1411 source: Some(ssgs.prefixer.clone()),
1412 sigers: Some(ssgs.sigers.clone()),
1413 cigar: None,
1414 })
1415 } else if !cigars.is_empty() {
1416 Ok(Message::Query {
1417 serder: Box::new(keri_serder.clone()),
1418 source: None,
1419 sigers: None,
1420 cigar: Some(cigars),
1421 })
1422 } else {
1423 let msg = format!(
1424 "Missing attached requester signature(s) to key log query msg = {}",
1425 keri_serder.pretty(None)
1426 );
1427 Err(MatterError::ValidationError(msg))
1428 };
1429 }
1430 else if ilk == Some(Ilk::Exn) {
1432 if !cigars.is_empty() {
1433 return Ok(Message::ExchangeEventNonTrans {
1434 serder,
1435 cigars,
1436 pathed: if pathed.is_empty() {
1437 None
1438 } else {
1439 Some(pathed)
1440 },
1441 essrs: if essrs.is_empty() { None } else { Some(essrs) },
1442 });
1443 }
1444
1445 if !tsgs.is_empty() {
1446 return Ok(Message::ExchangeEventTrans {
1447 serder,
1448 tsgs,
1449 pathed: if pathed.is_empty() {
1450 None
1451 } else {
1452 Some(pathed)
1453 },
1454 essrs: if essrs.is_empty() { None } else { Some(essrs) },
1455 });
1456 }
1457
1458 let msg = format!(
1459 "Missing attached signatures for exchange message = {}",
1460 keri_serder.pretty(None)
1461 );
1462 return Err(MatterError::ValidationError(msg));
1463 }
1464 else if ilk == Some(Ilk::Vcp)
1466 || ilk == Some(Ilk::Vrt)
1467 || ilk == Some(Ilk::Iss)
1468 || ilk == Some(Ilk::Rev)
1469 || ilk == Some(Ilk::Bis)
1470 || ilk == Some(Ilk::Brv)
1471 {
1472 let (seqner, saider) = sscs
1474 .last()
1475 .map(|sscs| (Some(sscs.seqner.clone()), Some(sscs.saider.clone())))
1476 .unwrap_or((None, None));
1477
1478 return Ok(Message::TELEvent {
1479 serder,
1480 seqner,
1481 saider,
1482 wigers: if wigers.is_empty() {
1483 None
1484 } else {
1485 Some(wigers)
1486 },
1487 });
1488 } else {
1489 let msg = format!(
1490 "Unexpected message ilk = {} for evt = {}",
1491 ilk.unwrap(),
1492 keri_serder.pretty(None)
1493 );
1494 return Err(MatterError::ValidationError(msg));
1495 }
1496 }
1497 else if let Some(acdc_serder) = serder.as_any().downcast_ref::<SerderACDC>() {
1499 let ilk = acdc_serder.ilk();
1500
1501 return if ilk.is_none() {
1502 let (prefixer, seqner, saider) = ssts
1505 .last()
1506 .map(|ssts| {
1507 (
1508 Some(ssts.prefixer.clone()),
1509 Some(ssts.seqner.clone()),
1510 Some(ssts.saider.clone()),
1511 )
1512 })
1513 .unwrap_or((None, None, None));
1514
1515 Ok(Message::Credential {
1516 creder: serder,
1517 prefixer,
1518 seqner,
1519 saider,
1520 })
1521 } else {
1522 let msg = format!(
1523 "Unexpected message ilk = {:?} for evt = {}",
1524 ilk,
1525 acdc_serder.pretty(None)
1526 );
1527 Err(MatterError::ValidationError(msg))
1528 };
1529 } else {
1530 let msg = format!(
1531 "Unexpected protocol type = {} for event message = {}",
1532 serder.proto(),
1533 serder.pretty(None)
1534 );
1535 return Err(MatterError::ValidationError(msg));
1536 }
1537
1538 Err(MatterError::ValidationError(
1540 "Failed to process message".to_string(),
1541 ))
1542 }
1543
1544 pub fn _extractor<T: Parsable>(
1563 &mut self,
1564 cold: &str,
1565 abort: bool,
1566 _gvrsn: &Versionage,
1567 ) -> Result<T, MatterError> {
1568 let result = match cold {
1571 "txt" => T::from_qb64b(&mut self.buffer, Some(true)),
1572 "bny" => T::from_qb2(&mut self.buffer, Some(true)),
1573 _ => Err(MatterError::ColdStartError(format!(
1574 "Invalid stream state cold={:?}.",
1575 cold
1576 ))),
1577 };
1578
1579 return match result {
1580 Ok(instance) => Ok(instance),
1581 Err(MatterError::ShortageError(_)) if !abort => {
1582 Err(MatterError::NeedMoreDataError(
1585 "Needs more data".to_string(),
1586 ))
1587 }
1588 Err(err) => Err(err),
1589 };
1590 }
1591
1592 pub fn sad_path_sig_group(
1604 &mut self,
1605 ctr: &BaseCounter,
1606 root: Option<&Pather>,
1607 cold: &str,
1608 pipelined: bool,
1609 gvrsn: &Versionage,
1610 ) -> Result<Vec<SadPathGroup>, MatterError> {
1611 if ctr.code() != ctr_dex_1_0::SAD_PATH_SIG_GROUPS {
1613 return Err(MatterError::UnexpectedCountCodeError(format!(
1614 "Wrong count code={}. Expected code={}.",
1615 ctr.code(),
1616 ctr_dex_1_0::SAD_PATH_SIG_GROUPS
1617 )));
1618 }
1619
1620 let mut subpath = self._extractor::<Pather>(cold, pipelined, gvrsn)?;
1622
1623 if let Some(_) = root {
1626 subpath = subpath.root();
1627 }
1628
1629 let sctr = self._extractor::<BaseCounter>(cold, pipelined, gvrsn)?;
1631
1632 let mut result = Vec::new();
1633
1634 match sctr.code() {
1636 ctr_dex_1_0::TRANS_IDX_SIG_GROUPS => {
1637 let trans_groups = self.trans_idx_sig_groups(&sctr, cold, pipelined, gvrsn)?;
1639
1640 for tsgs in trans_groups {
1641 let group = SadPathGroup::TransIdxSig(
1642 SadTsgs {
1643 path: subpath.clone(),
1644 prefixer: tsgs.prefixer,
1645 seqner: tsgs.seqner,
1646 saider: tsgs.saider,
1647 sigers: tsgs.sigers,
1648 }
1649 .clone(),
1650 );
1651 result.push(group);
1652 }
1653 }
1654
1655 ctr_dex_1_0::CONTROLLER_IDX_SIGS => {
1656 let mut isigers = Vec::with_capacity(sctr.count() as usize);
1658
1659 for _ in 0..sctr.count() {
1660 let isiger = self._extractor::<Siger>(cold, pipelined, gvrsn)?;
1661 isigers.push(isiger);
1662 }
1663
1664 let group = SadPathGroup::ControllerIdxSig(SadSigers {
1665 path: subpath,
1666 sigers: isigers,
1667 });
1668 result.push(group);
1669 }
1670
1671 ctr_dex_1_0::NON_TRANS_RECEIPT_COUPLES => {
1672 let cigars = self.non_trans_receipt_couples(&sctr, cold, pipelined, gvrsn)?;
1674
1675 for cigar in cigars {
1676 let group = SadPathGroup::NonTransReceipt(SadCigars {
1677 path: subpath.clone(),
1678 cigar,
1679 });
1680 result.push(group);
1681 }
1682 }
1683
1684 _ => {
1685 return Err(MatterError::UnexpectedCountCodeError(format!(
1686 "Wrong count code={}. Expected one of TransIdxSigGroups, ControllerIdxSigs, or NonTransReceiptCouples.",
1687 sctr.code()
1688 )));
1689 }
1690 }
1691
1692 Ok(result)
1693 }
1694
1695 pub fn trans_idx_sig_groups(
1712 &mut self,
1713 ctr: &BaseCounter,
1714 cold: &str,
1715 pipelined: bool,
1716 gvrsn: &Versionage,
1717 ) -> Result<Vec<Tsgs>, MatterError> {
1718 let mut groups = Vec::with_capacity(ctr.count() as usize);
1719
1720 for _ in 0..ctr.count() {
1721 let prefixer = self._extractor::<Prefixer>(cold, pipelined, gvrsn)?;
1723
1724 let seqner = self._extractor::<Seqner>(cold, pipelined, gvrsn)?;
1726
1727 let saider = self._extractor::<Saider>(cold, pipelined, gvrsn)?;
1729
1730 let ictr = self._extractor::<BaseCounter>(cold, pipelined, gvrsn)?;
1732
1733 if ictr.code() != ctr_dex_1_0::CONTROLLER_IDX_SIGS {
1735 return Err(MatterError::UnexpectedCountCodeError(format!(
1736 "Wrong count code={}. Expected code={}.",
1737 ictr.code(),
1738 ctr_dex_1_0::CONTROLLER_IDX_SIGS
1739 )));
1740 }
1741
1742 let mut isigers = Vec::with_capacity(ictr.count() as usize);
1744 for _ in 0..ictr.count() {
1745 let isiger = self._extractor::<Siger>(cold, pipelined, gvrsn)?;
1746 isigers.push(isiger);
1747 }
1748
1749 groups.push(Tsgs {
1751 prefixer,
1752 seqner,
1753 saider,
1754 sigers: isigers,
1755 });
1756 }
1757
1758 Ok(groups)
1759 }
1760
1761 pub fn non_trans_receipt_couples(
1774 &mut self,
1775 ctr: &BaseCounter,
1776 cold: &str,
1777 pipelined: bool,
1778 gvrsn: &Versionage,
1779 ) -> Result<Vec<Cigar>, MatterError> {
1780 let mut cigars = Vec::with_capacity(ctr.count() as usize);
1781
1782 for _ in 0..ctr.count() {
1783 let verfer = self._extractor::<Verfer>(cold, pipelined, gvrsn)?;
1785
1786 let mut cigar = self._extractor::<Cigar>(cold, pipelined, gvrsn)?;
1788
1789 cigar.verfer = Some(verfer);
1791
1792 cigars.push(cigar);
1794 }
1795
1796 Ok(cigars)
1797 }
1798}
1799
1800impl<R: AsyncRead + Unpin + Send> Parser<R> {
1801 pub async fn parse_stream(&mut self, once: Option<bool>) -> Result<(), KERIError> {
1802 let mut first_read = true;
1803 let mut loop_count = 0;
1804 let max_duration = Duration::from_secs(30); let start_time = Instant::now();
1806
1807 let mut force_read = false;
1809 let mut reached_eof = false;
1811
1812 loop {
1813 if start_time.elapsed() > max_duration {
1814 return Err(KERIError::Parsing("Parser operation timed out".to_string()));
1815 }
1816
1817 loop_count += 1;
1818 if loop_count > 1000 {
1819 return Err(KERIError::Parsing(
1820 "Possible infinite loop detected".to_string(),
1821 ));
1822 }
1823
1824 if first_read || self.buffer.len() < 100 || force_read {
1829 first_read = false;
1830 force_read = false; let mut chunk = vec![0u8; 8192]; let n = self.reader.read(&mut chunk).await?;
1836 if n == 0 {
1837 reached_eof = true;
1839
1840 if self.buffer.is_empty() {
1841 break;
1842 }
1843 } else {
1845 self.buffer.extend_from_slice(&chunk[..n]);
1847 }
1848 }
1849
1850 let mut made_progress = false;
1851 loop {
1852 if self.attachment_processing && self.buffer.get(0) == Some(&45) {
1854 if self.current_serder.is_none() {
1856 self.attachment_processing = false;
1857 }
1858 }
1859
1860 match self.try_parse_message() {
1861 Ok((msg, _size)) => {
1862 made_progress = true;
1863
1864 self.attachment_processing = false;
1866 self.current_serder = None;
1867
1868 if let Err(e) = self.dispatch_message(msg).await {
1870 match e {
1871 KERIError::ValidationError(_) => {}
1873 KERIError::OutOfOrderError(msg) => {
1874 if !msg.contains("Diagnostic") {}
1876 }
1877 _ => {
1878 return Err(e);
1879 }
1880 }
1881 }
1882 }
1883 Err(e) => {
1884 if let MatterError::NeedMoreDataError(msg) = &e {
1886 if msg.contains("Not enough data for attachments")
1888 && !self.buffer.is_empty()
1889 && self.buffer[0] == 45
1890 {
1891 self.attachment_processing = true;
1893 }
1894
1895 if reached_eof {
1896 self.attachment_processing = false;
1899 self.current_serder = None;
1900
1901 self.buffer.clear();
1903 break;
1904 } else {
1905 force_read = true;
1907 break;
1908 }
1909 } else {
1910 self.attachment_processing = false;
1913 self.current_serder = None;
1914 return Err(KERIError::MatterError(e.to_string()));
1915 }
1916 }
1917 }
1918
1919 if self.buffer.is_empty() {
1920 self.attachment_processing = false;
1922 self.current_serder = None;
1923
1924 if once.unwrap_or(false) {
1925 return Ok(());
1926 }
1927 break;
1928 }
1929 }
1930
1931 if self.buffer.is_empty() {
1932 break;
1933 }
1934
1935 if reached_eof && !made_progress && !force_read {
1936 self.attachment_processing = false;
1938 self.current_serder = None;
1939
1940 if !self.buffer.is_empty() {
1942 self.buffer.clear();
1943 }
1944 break;
1945 }
1946 }
1947
1948 Ok(())
1949 }
1950}
1951
1952#[cfg(test)]
1953mod tests {
1954 use super::*;
1955 use crate::cesr::diger::Diger;
1956 use crate::cesr::signing::{Salter, Sigmat};
1957 use crate::cesr::BaseMatter;
1958 use crate::keri::core::eventing::{
1959 InceptionEventBuilder, InteractEventBuilder, Kever, KeveryBuilder, RotateEventBuilder,
1960 };
1961 use crate::keri::core::serdering::Rawifiable;
1962 use crate::keri::db::basing::Baser;
1963 use crate::keri::db::dbing::LMDBer;
1964 use crate::Matter;
1965
1966 #[test]
1967 fn test_parse_messages_without_handlers() -> Result<(), KERIError> {
1968 let resources = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/resources");
1969
1970 let kel = std::fs::read(resources.join("20-evt.cesr")).unwrap();
1972 let mut parser = Parser::without_handlers(std::io::empty(), true, false, false);
1973 let msgs = parser.parse_messages(&kel)?;
1974 assert_eq!(msgs.len(), 20);
1975 assert!(msgs
1976 .iter()
1977 .all(|m| matches!(m, Message::KeyEvent { sigers: Some(s), .. } if !s.is_empty())));
1978
1979 let oobi = std::fs::read(resources.join("keripy-wan-oobi.cesr")).unwrap();
1981 let msgs = parser.parse_messages(&oobi)?;
1982 assert_eq!(msgs.len(), 4);
1983 assert!(matches!(msgs[0], Message::KeyEvent { .. }));
1984 assert!(msgs[1..]
1985 .iter()
1986 .all(|m| matches!(m, Message::ReplyNonTrans { cigars, .. } if cigars.len() == 1)));
1987
1988 assert!(parser.parse_one(&kel).is_err());
1990 Ok(())
1991 }
1992
1993 #[tokio::test]
1994 async fn test_parse_kel_file() -> Result<(), KERIError> {
1995 use std::fs;
1996 use std::path::PathBuf;
1997 use std::sync::{Arc, Mutex};
1998 use tokio::io::BufReader;
1999
2000 let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
2002 path.push("src/resources/20-evt.cesr");
2003
2004 let kel_data = fs::read(&path)?;
2006 assert!(!kel_data.is_empty(), "KEL file should not be empty");
2007 assert!(
2008 kel_data.len() > 1000,
2009 "KEL file should contain significant data"
2010 );
2011
2012 let reader = BufReader::new(&kel_data[..]);
2013
2014 let lmdber = LMDBer::builder().name("test_kevery").temp(true).build()?;
2016 let baser = Baser::new(Arc::new(lmdber))?;
2017 let db = Arc::new(baser);
2018
2019 let kevery = Kevery::new(
2021 None, db.clone(), None, Some(true), Some(false), Some(false), Some(false), Some(false), )?;
2030
2031 let handlers = Handlers {
2033 kevery: Arc::new(Mutex::new(kevery)),
2034 tevery: Arc::new(MockHandler { serder: None }),
2035 exchanger: Arc::new(MockHandler { serder: None }),
2036 revery: Arc::new(MockHandler { serder: None }),
2037 verifier: Arc::new(MockHandler { serder: None }),
2038 local: false,
2039 };
2040
2041 let mut parser = Parser::new(reader, true, false, handlers);
2043
2044 let parse_result = parser.parse_stream(Some(true)).await;
2046 assert!(
2047 parse_result.is_ok(),
2048 "File should parse successfully: {:?}",
2049 parse_result.err()
2050 );
2051
2052 let identifier = "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o";
2054
2055 let msgs = db.clone_pre_iter(identifier, None)?;
2057
2058 assert!(
2060 !msgs.is_empty(),
2061 "No events found in database for identifier {}",
2062 identifier
2063 );
2064 assert!(
2065 msgs.len() >= 10,
2066 "Expected at least 10 events, found {}",
2067 msgs.len()
2068 );
2069
2070 let events = msgs
2072 .iter()
2073 .map(|msg| SerderKERI::from_raw(msg, None))
2074 .collect::<Result<Vec<_>, _>>()?;
2075
2076 assert_eq!(
2078 events.len(),
2079 20,
2080 "Expected exactly 100 events in the KEL file"
2081 );
2082
2083 let inception = &events[0];
2085 assert_eq!(
2086 inception.said().unwrap(),
2087 "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o"
2088 );
2089 assert_eq!(
2090 inception.pre().unwrap(),
2091 "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o"
2092 );
2093 assert_eq!(inception.sn().unwrap(), 0);
2094 assert_eq!(inception.ilk().unwrap(), Ilk::Icp);
2095
2096 let kt_val = inception.base.sad.get("kt").unwrap().as_str().unwrap();
2098 assert_eq!(kt_val, "1", "Expected threshold of 1 for inception event");
2099
2100 let keys = inception.base.sad.get("k").unwrap().as_array().unwrap();
2101 assert_eq!(keys.len(), 1, "Expected 1 key in inception event");
2102 assert_eq!(
2103 keys[0].as_str().unwrap(),
2104 "DKizX87vfaKLrB25LfEcKHt1IQwCacRSnZXiesQnhVVe"
2105 );
2106
2107 let nt_val = inception.base.sad.get("nt").unwrap().as_str().unwrap();
2109 assert_eq!(
2110 nt_val, "1",
2111 "Expected next threshold of 1 for inception event"
2112 );
2113
2114 let next_keys = inception.base.sad.get("n").unwrap().as_array().unwrap();
2115 assert_eq!(next_keys.len(), 1, "Expected 1 next key in inception event");
2116 assert_eq!(
2117 next_keys[0].as_str().unwrap(),
2118 "EJe7Mrj1e5_0H1Qy49Bzurn1KKDaK4-zOPUhwri_pLfb"
2119 );
2120
2121 let rotation1 = &events[1];
2123 assert_eq!(rotation1.ilk().unwrap(), Ilk::Rot);
2124 assert_eq!(rotation1.sn().unwrap(), 1);
2125 assert_eq!(
2126 rotation1.pre().unwrap(),
2127 "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o"
2128 );
2129 assert_eq!(
2130 rotation1.said().unwrap(),
2131 "EO7KEi5RveInYUzrDPrhlYzpgDTwEEvgEk2exxIQuRHO"
2132 );
2133
2134 let prev_dig = rotation1.base.sad.get("p").unwrap().as_str().unwrap();
2136 assert_eq!(
2137 prev_dig, "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o",
2138 "First rotation's previous digest should reference inception event"
2139 );
2140
2141 let rot1_keys = rotation1.base.sad.get("k").unwrap().as_array().unwrap();
2143 assert_eq!(
2144 rot1_keys[0].as_str().unwrap(),
2145 "DAZUzGSCJobcEC1ZFgy_uWmzeazSVLSIYdXZoJhuoZWz",
2146 "Keys should have changed in first rotation"
2147 );
2148
2149 for i in 1..events.len() {
2151 let curr = &events[i];
2152 let prev = &events[i - 1];
2153
2154 let curr_sn = curr.sn().unwrap();
2156 let prev_sn = prev.sn().unwrap();
2157
2158 assert_eq!(
2159 curr_sn,
2160 prev_sn + 1,
2161 "Non-sequential events at index {}: prev_sn={}, curr_sn={}",
2162 i,
2163 prev_sn,
2164 curr_sn
2165 );
2166
2167 let curr_prev_dig = curr.base.sad.get("p").unwrap().as_str().unwrap();
2169 let prev_said = prev.said().unwrap();
2170
2171 assert_eq!(
2172 curr_prev_dig, prev_said,
2173 "Event chain broken at index {}: expected previous digest '{}', got '{}'",
2174 i, prev_said, curr_prev_dig
2175 );
2176 }
2177
2178 let mut key_changes = 0;
2180 let mut current_key = keys[0].as_str().unwrap();
2181
2182 for event in &events {
2183 if event.ilk().unwrap() == Ilk::Rot {
2184 let rot_keys = event.base.sad.get("k").unwrap().as_array().unwrap();
2186 let new_key = rot_keys[0].as_str().unwrap();
2187
2188 if new_key != current_key {
2189 key_changes += 1;
2190 current_key = new_key;
2191 }
2192 }
2193 }
2194
2195 assert!(
2196 key_changes >= 5,
2197 "Expected at least 5 key rotations, found {}",
2198 key_changes
2199 );
2200
2201 let event_types = events.iter().map(|e| e.ilk().unwrap()).fold(
2203 std::collections::HashMap::new(),
2204 |mut map, ilk| {
2205 *map.entry(ilk).or_insert(0) += 1;
2206 map
2207 },
2208 );
2209
2210 assert!(
2211 event_types.contains_key(&Ilk::Icp),
2212 "Should have inception event"
2213 );
2214 assert!(
2215 event_types.contains_key(&Ilk::Rot),
2216 "Should have rotation events"
2217 );
2218 assert!(
2219 event_types.contains_key(&Ilk::Ixn),
2220 "Should have interaction events"
2221 );
2222
2223 let anchored_events = events
2225 .iter()
2226 .filter(|e| {
2227 e.base
2228 .sad
2229 .get("a")
2230 .map_or(false, |a| a.as_array().map_or(false, |arr| !arr.is_empty()))
2231 })
2232 .count();
2233
2234 assert!(
2235 anchored_events > 0,
2236 "Expected at least one event with anchors"
2237 );
2238
2239 Ok(())
2241 }
2242
2243 struct MockHandler {
2244 serder: Option<Box<dyn Serder>>,
2245 }
2246
2247 #[async_trait::async_trait]
2248 impl MessageHandler for MockHandler {
2249 fn handle(
2250 &self,
2251 _msg: Message,
2252 ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), KERIError>> + Send + '_>>
2253 {
2254 Box::pin(async {
2255 let _serder = match _msg {
2256 Message::KeyEvent { serder, .. } => Some(Box::new(serder)),
2257 _ => None,
2258 };
2259 Ok(())
2260 })
2261 }
2262 }
2263
2264 #[tokio::test]
2265 async fn test_parser_valid_message() {
2266 let pre = "DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx";
2268 let said = "EIcca2-uqsicYK7-q5gxlZXuzOkqrNSL3JIaLflSOOgF";
2269
2270 let input = r#"{"v":"KERI10JSON00012b_","t":"icp","d":"EIcca2-uqsicYK7-q5gxlZXuzOkqrNSL3JIaLflSOOgF","i":"DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx","s":"0","kt":"1","k":["DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx"],"nt":"1","n":["EFXIx7URwmw7AVQTBcMxPXfOOJ2YYA1SJAam69DXV8D2"],"bt":"0","b":[],"c":[],"a":[]}-AABAAApXLez5eVIs6YyRXOMDMBy4cTm2GvsilrZlcMmtBbO5twLst_jjFoEyfKTWKntEtv9JPBv1DLkqg-ImDmGPM8E"#.as_bytes();
2271 let reader = tokio::io::BufReader::new(input);
2272
2273 let lmdber = LMDBer::builder()
2275 .temp(true)
2276 .name("test_kevery_builder")
2277 .build()
2278 .expect("LMDBer should be build");
2279
2280 let db = Arc::new(Baser::new(Arc::new(lmdber)).expect("Baser should be built"));
2281
2282 let kevery = KeveryBuilder::new(db.clone())
2284 .with_lax(true)
2285 .with_local(false)
2286 .with_cloned(false)
2287 .with_direct(true)
2288 .with_check(false)
2289 .build()
2290 .expect("Should build a Kevery");
2291
2292 let handlers = Handlers {
2293 kevery: Arc::new(kevery.into()),
2294 tevery: Arc::new(MockHandler { serder: None }),
2295 exchanger: Arc::new(MockHandler { serder: None }),
2296 revery: Arc::new(MockHandler { serder: None }),
2297 verifier: Arc::new(MockHandler { serder: None }),
2298 local: false,
2299 };
2300
2301 let mut parser = Parser::new(reader, true, false, handlers);
2302 assert!(parser.parse_stream(Some(true)).await.is_ok());
2303
2304 let msgs = db
2305 .clone_pre_iter("DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx", None)
2306 .expect("Clone failed");
2307 assert_eq!(msgs.len(), 1);
2308 let msg = msgs.get(0).unwrap();
2309
2310 let bytes = concat!(
2311 r#"{"v":"KERI10JSON00012b_","t":"icp","d":"EIcca2-uqsicYK7-q5gxlZXuzOkqrNSL3JIaLflSOOgF","i":"DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx","s":"0","kt":"1","k":["DNG2arBDtHK_JyHRAq-emRdC6UM-yIpCAeJIWDiXp4Hx"],"nt":"1","n":["EFXIx7URwmw7AVQTBcMxPXfOOJ2YYA1SJAam69DXV8D2"],"bt":"0","b":[],"c":[],"a":[]}"#,
2312 r#"-VAn-AABAAApXLez5eVIs6YyRXOMDMBy4cTm2GvsilrZlcMmtBbO5twLst_jjFoEyfKTWKntEtv9JPBv1DLkqg-ImDmGPM8E"#
2313 ).as_bytes();
2314
2315 assert!(msg.starts_with(bytes));
2316 }
2317
2318 #[tokio::test]
2319 async fn test_parser() -> Result<(), KERIError> {
2320 let raw = b"ABCDEFGH01234567";
2322 let salter = Salter::new(Some(raw), None, None);
2323 let signers = salter
2324 .unwrap()
2325 .signers(8, 0, "psr", None, None, None, true)?;
2326
2327 let con_lmdber = LMDBer::builder().name("controller").temp(true).build()?;
2329 let val_lmdber = LMDBer::builder().name("validator").temp(true).build()?;
2330
2331 let con_db = Arc::new(Baser::new(Arc::new(con_lmdber))?);
2332 let val_db = Arc::new(Baser::new(Arc::new(val_lmdber))?);
2333
2334 let mut event_digs = Vec::new();
2335 let mut msgs = Vec::new();
2336
2337 let keys = vec![signers[0].verfer.qb64()];
2338 let ndigs = vec![Diger::from_ser(&signers[1].verfer.qb64b(), None)?.qb64()];
2339
2340 let serder = InceptionEventBuilder::new(keys).with_ndigs(ndigs).build()?;
2341 event_digs.push(serder.said().unwrap());
2342
2343 let counter = BaseCounter::from_code_and_count(
2345 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2346 Some(1),
2347 Some("1.0"),
2348 )
2349 .unwrap();
2350
2351 let siger = match signers[0].sign(&serder.raw(), Some(0), None, None)? {
2353 Sigmat::Indexed(siger) => siger,
2354 Sigmat::NonIndexed(_) => {
2355 panic!("Should not be non-indexed")
2356 }
2357 };
2358
2359 let mut kever = Kever::new(
2361 con_db.clone(),
2362 &crate::keri::core::eventing::kevery::Locals::default(),
2363 None,
2364 Some(serder.clone()),
2365 Some(vec![siger.clone()]),
2366 None,
2367 None,
2368 None,
2369 None,
2370 None,
2371 None,
2372 None,
2373 None,
2374 None,
2375 )?;
2376
2377 msgs.extend_from_slice(&serder.raw());
2379 msgs.extend_from_slice(&counter.qb64b());
2380 msgs.extend_from_slice(&siger.qb64b());
2381
2382 let pre = kever.prefixer().unwrap().qb64();
2384 let keys = vec![signers[1].verfer.qb64()];
2385 let srd = kever.serder().unwrap();
2386 let dig = srd.said().unwrap();
2387 let ndigs = vec![Diger::from_ser(&signers[2].verfer.qb64b(), None)?.qb64()];
2388
2389 let serder = RotateEventBuilder::new(pre, keys, dig.to_string())
2390 .with_sn(1)
2391 .with_ndigs(ndigs)
2392 .build()?;
2393
2394 event_digs.push(serder.said().unwrap());
2395
2396 let counter = BaseCounter::from_code_and_count(
2398 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2399 Some(1),
2400 Some("1.0"),
2401 )?;
2402 let siger = match signers[1].sign(&serder.raw(), Some(0), None, None)? {
2404 Sigmat::Indexed(siger) => siger,
2405 Sigmat::NonIndexed(_) => {
2406 panic!("Should not be non-indexed")
2407 }
2408 };
2409
2410 kever.update(
2411 &crate::keri::core::eventing::kevery::Locals::default(),
2412 serder.clone(),
2413 vec![siger.clone()],
2414 Some(Vec::new()),
2415 None,
2416 None,
2417 None,
2418 None,
2419 true,
2420 true,
2421 false,
2422 )?;
2423 msgs.extend_from_slice(&serder.raw());
2425 msgs.extend_from_slice(&counter.qb64b());
2426 msgs.extend_from_slice(&siger.qb64b());
2427
2428 let pre = kever.prefixer().unwrap().qb64();
2430 let keys = vec![signers[2].verfer.qb64()];
2431 let srd = kever.serder().unwrap();
2432 let dig = srd.said().unwrap();
2433 let ndigs = vec![Diger::from_ser(&signers[3].verfer.qb64b(), None)?.qb64()];
2434
2435 let serder = RotateEventBuilder::new(pre, keys, dig.to_string())
2436 .with_sn(2)
2437 .with_ndigs(ndigs)
2438 .build()?;
2439 event_digs.push(serder.said().unwrap());
2440
2441 let counter = BaseCounter::from_code_and_count(
2443 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2444 Some(1),
2445 Some("1.0"),
2446 )
2447 .unwrap();
2448
2449 let siger = match signers[2].sign(&serder.raw(), Some(0), None, None)? {
2451 Sigmat::Indexed(siger) => siger,
2452 Sigmat::NonIndexed(_) => {
2453 panic!("Should not be non-indexed")
2454 }
2455 };
2456
2457 kever.update(
2459 &crate::keri::core::eventing::kevery::Locals::default(),
2460 serder.clone(),
2461 vec![siger.clone()],
2462 None,
2463 None,
2464 None,
2465 None,
2466 None,
2467 true,
2468 true,
2469 false,
2470 )?;
2471
2472 msgs.extend_from_slice(&serder.raw());
2474 msgs.extend_from_slice(&counter.qb64b());
2475 msgs.extend_from_slice(&siger.qb64b());
2476
2477 let pre = kever.prefixer().unwrap().qb64();
2479 let srd = kever.serder().unwrap();
2480 let dig = srd.said().unwrap();
2481
2482 let serder = InteractEventBuilder::new(pre, dig.to_string())
2483 .with_sn(3)
2484 .build()?;
2485
2486 event_digs.push(serder.said().unwrap());
2487
2488 let counter = BaseCounter::from_code_and_count(
2490 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2491 Some(1),
2492 Some("1.0"),
2493 )
2494 .unwrap();
2495
2496 let siger = match signers[2].sign(&serder.raw(), Some(0), None, None)? {
2498 Sigmat::Indexed(siger) => siger,
2499 Sigmat::NonIndexed(_) => {
2500 panic!("Should not be non-indexed")
2501 }
2502 };
2503
2504 kever.update(
2506 &crate::keri::core::eventing::kevery::Locals::default(),
2507 serder.clone(),
2508 vec![siger.clone()],
2509 None,
2510 None,
2511 None,
2512 None,
2513 None,
2514 true,
2515 true,
2516 false,
2517 )?;
2518
2519 msgs.extend_from_slice(&serder.raw());
2521 msgs.extend_from_slice(&counter.qb64b());
2522 msgs.extend_from_slice(&siger.qb64b());
2523
2524 let pre = kever.prefixer().unwrap().qb64();
2526 let srd = kever.serder().unwrap();
2527 let dig = srd.said().unwrap();
2528
2529 let serder = InteractEventBuilder::new(pre, dig.to_string())
2530 .with_sn(4)
2531 .build()?;
2532
2533 event_digs.push(serder.said().unwrap());
2534
2535 let counter = BaseCounter::from_code_and_count(
2537 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2538 Some(1),
2539 Some("1.0"),
2540 )?;
2541
2542 let siger = match signers[2].sign(&serder.raw(), Some(0), None, None)? {
2544 Sigmat::Indexed(siger) => siger,
2545 Sigmat::NonIndexed(_) => {
2546 panic!("Should not be non-indexed")
2547 }
2548 };
2549
2550 kever.update(
2552 &crate::keri::core::eventing::kevery::Locals::default(),
2553 serder.clone(),
2554 vec![siger.clone()],
2555 None,
2556 None,
2557 None,
2558 None,
2559 None,
2560 true,
2561 true,
2562 false,
2563 )?;
2564
2565 msgs.extend_from_slice(&serder.raw());
2567 msgs.extend_from_slice(&counter.qb64b());
2568 msgs.extend_from_slice(&siger.qb64b());
2569
2570 let pre = kever.prefixer().unwrap().qb64();
2572 let keys = vec![signers[3].verfer.qb64()];
2573 let srd = kever.serder().unwrap();
2574 let dig = srd.said().unwrap();
2575 let ndigs = vec![Diger::from_ser(&signers[4].verfer.qb64b(), None)?.qb64()];
2576
2577 let serder = RotateEventBuilder::new(pre, keys, dig.to_string())
2578 .with_sn(5)
2579 .with_ndigs(ndigs)
2580 .build()?;
2581 event_digs.push(serder.said().unwrap());
2582
2583 let counter = BaseCounter::from_code_and_count(
2585 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2586 Some(1),
2587 Some("1.0"),
2588 )
2589 .unwrap();
2590
2591 let siger = match signers[3].sign(&serder.raw(), Some(0), None, None)? {
2593 Sigmat::Indexed(siger) => siger,
2594 Sigmat::NonIndexed(_) => {
2595 panic!("Should not be non-indexed")
2596 }
2597 };
2598
2599 kever.update(
2601 &crate::keri::core::eventing::kevery::Locals::default(),
2602 serder.clone(),
2603 vec![siger.clone()],
2604 None,
2605 None,
2606 None,
2607 None,
2608 None,
2609 true,
2610 true,
2611 false,
2612 )?;
2613
2614 msgs.extend_from_slice(&serder.raw());
2616 msgs.extend_from_slice(&counter.qb64b());
2617 msgs.extend_from_slice(&siger.qb64b());
2618
2619 let pre = kever.prefixer().unwrap().qb64();
2621 let srd = kever.serder().unwrap();
2622 let dig = srd.said().unwrap();
2623
2624 let serder = InteractEventBuilder::new(pre, dig.to_string())
2625 .with_sn(6)
2626 .build()?;
2627 event_digs.push(serder.said().unwrap());
2628
2629 let counter = BaseCounter::from_code_and_count(
2631 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2632 Some(1),
2633 Some("1.0"),
2634 )?;
2635
2636 let siger = match signers[3].sign(&serder.raw(), Some(0), None, None)? {
2638 Sigmat::Indexed(siger) => siger,
2639 Sigmat::NonIndexed(_) => {
2640 panic!("Should not be non-indexed")
2641 }
2642 };
2643
2644 kever.update(
2646 &crate::keri::core::eventing::kevery::Locals::default(),
2647 serder.clone(),
2648 vec![siger.clone()],
2649 None,
2650 None,
2651 None,
2652 None,
2653 None,
2654 true,
2655 true,
2656 false,
2657 )?;
2658
2659 msgs.extend_from_slice(&serder.raw());
2661 msgs.extend_from_slice(&counter.qb64b());
2662 msgs.extend_from_slice(&siger.qb64b());
2663
2664 let pre = kever.prefixer().unwrap().qb64();
2667 let keys = vec![signers[4].verfer.qb64()];
2668 let srd = kever.serder().unwrap();
2669 let dig = srd.said().unwrap();
2670
2671 let serder = RotateEventBuilder::new(pre, keys, dig.to_string())
2672 .with_sn(7)
2673 .with_ndigs(vec![])
2675 .build()?;
2676
2677 event_digs.push(serder.said().unwrap());
2678
2679 let counter = BaseCounter::from_code_and_count(
2681 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2682 Some(1),
2683 Some("1.0"),
2684 )?;
2685
2686 let siger = match signers[4].sign(&serder.raw(), Some(0), None, None)? {
2688 Sigmat::Indexed(siger) => siger,
2689 Sigmat::NonIndexed(_) => {
2690 panic!("Should not be non-indexed")
2691 }
2692 };
2693
2694 kever.update(
2696 &crate::keri::core::eventing::kevery::Locals::default(),
2697 serder.clone(),
2698 vec![siger.clone()],
2699 None,
2700 None,
2701 None,
2702 None,
2703 None,
2704 true,
2705 true,
2706 false,
2707 )?;
2708
2709 msgs.extend_from_slice(&serder.raw());
2711 msgs.extend_from_slice(&counter.qb64b());
2712 msgs.extend_from_slice(&siger.qb64b());
2713
2714 let pre = kever.prefixer().unwrap().qb64();
2716 let srd = kever.serder().unwrap();
2717 let dig = srd.said().unwrap();
2718
2719 let serder = InteractEventBuilder::new(pre, dig.to_string())
2720 .with_sn(8)
2721 .build()?;
2722
2723 let counter = BaseCounter::from_code_and_count(
2725 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2726 Some(1),
2727 Some("1.0"),
2728 )
2729 .unwrap();
2730
2731 let siger = match signers[4].sign(&serder.raw(), Some(0), None, None)? {
2733 Sigmat::Indexed(siger) => siger,
2734 Sigmat::NonIndexed(_) => {
2735 panic!("Should not be non-indexed")
2736 }
2737 };
2738
2739 let result = kever.update(
2741 &crate::keri::core::eventing::kevery::Locals::default(),
2742 serder.clone(),
2743 vec![siger.clone()],
2744 None,
2745 None,
2746 None,
2747 None,
2748 None,
2749 true,
2750 true,
2751 false,
2752 );
2753 assert!(result.is_err());
2754 assert!(matches!(result.unwrap_err(), KERIError::ValidationError(_)));
2755
2756 msgs.extend_from_slice(&serder.raw());
2758 msgs.extend_from_slice(&counter.qb64b());
2759 msgs.extend_from_slice(&siger.qb64b());
2760
2761 let pre = kever.prefixer().unwrap().qb64();
2763 let keys = vec![signers[4].verfer.qb64()];
2764 let srd = kever.serder().unwrap();
2765 let dig = srd.said().unwrap();
2766 let ndigs = vec![Diger::from_ser(signers[5].verfer.raw(), None)?.qb64()];
2767
2768 let serder = RotateEventBuilder::new(pre, keys, dig.to_string())
2769 .with_sn(8)
2770 .with_ndigs(ndigs)
2771 .build()?;
2772
2773 let counter = BaseCounter::from_code_and_count(
2775 Some(ctr_dex_1_0::CONTROLLER_IDX_SIGS),
2776 Some(1),
2777 Some("1.0"),
2778 )
2779 .unwrap();
2780
2781 let siger = match signers[4].sign(&serder.raw(), Some(0), None, None)? {
2783 Sigmat::Indexed(siger) => siger,
2784 Sigmat::NonIndexed(_) => {
2785 panic!("Should not be non-indexed")
2786 }
2787 };
2788
2789 let result = kever.update(
2791 &crate::keri::core::eventing::kevery::Locals::default(),
2792 serder.clone(),
2793 vec![siger.clone()],
2794 None,
2795 None,
2796 None,
2797 None,
2798 None,
2799 true,
2800 true,
2801 false,
2802 );
2803 assert!(result.is_err());
2804 assert!(matches!(result.unwrap_err(), KERIError::ValidationError(_)));
2805
2806 msgs.extend_from_slice(&serder.raw());
2808 msgs.extend_from_slice(&counter.qb64b());
2809 msgs.extend_from_slice(&siger.qb64b());
2810
2811 assert_eq!(msgs.len(), 3745);
2813
2814 let pre = kever.prefixer().unwrap().qb64();
2815
2816 let db_digs: Vec<String> = con_db
2818 .clone_pre_iter(&pre, None)?
2819 .iter()
2820 .map(|msg| {
2821 let serder = SerderKERI::from_raw(&msg, None).unwrap();
2822 serder.said().unwrap().to_string()
2823 })
2824 .collect();
2825
2826 assert_eq!(db_digs, event_digs);
2827
2828 let kevery = Kevery::new(
2830 None,
2831 val_db.clone(),
2832 None,
2833 Some(false),
2834 Some(false),
2835 Some(false),
2836 Some(false),
2837 Some(false),
2838 )?;
2839
2840 let handlers = Handlers {
2841 kevery: Arc::new(Mutex::new(kevery)),
2842 tevery: Arc::new(MockHandler { serder: None }),
2843 exchanger: Arc::new(MockHandler { serder: None }),
2844 revery: Arc::new(MockHandler { serder: None }),
2845 verifier: Arc::new(MockHandler { serder: None }),
2846 local: false,
2847 };
2848
2849 let mut parser = Parser::new(msgs.as_slice(), true, false, handlers);
2850
2851 assert!(parser.parse_stream(Some(true)).await.is_ok());
2853
2854 assert!(parser
2856 .handlers.as_ref().unwrap()
2857 .kevery
2858 .lock()
2859 .unwrap()
2860 .kevers()
2861 .contains_key(&pre));
2862
2863 let lock = parser.handlers.as_ref().unwrap().kevery.lock().unwrap();
2864 let vkever = lock.kevers().get(&pre).unwrap();
2865 assert_eq!(vkever.sner().unwrap().num(), kever.sner().unwrap().num());
2867 assert_eq!(
2868 vkever.verfers().unwrap()[0].qb64(),
2869 kever.verfers().unwrap()[0].qb64()
2870 );
2871 assert_eq!(
2872 vkever.verfers().unwrap()[0].qb64(),
2873 signers[4].verfer.qb64()
2874 );
2875
2876 let val_db_digs: Vec<String> = val_db
2878 .clone_pre_iter(&pre, None)?
2879 .iter()
2880 .map(|msg| {
2881 let serder = SerderKERI::from_raw(&msg, None).unwrap();
2882 serder.said().unwrap().to_string()
2883 })
2884 .collect();
2885
2886 assert_eq!(val_db_digs, event_digs);
2887
2888 let mut no_handler_parser = Parser::new(msgs.as_slice(), true, false, Handlers::default());
2891 assert!(no_handler_parser.parse_stream(Some(true)).await.is_ok());
2892
2893 Ok(())
2895 }
2896 impl Default for Handlers {
2897 fn default() -> Self {
2898 let lmdber = Arc::new(LMDBer::builder().temp(true).name("temp").build().unwrap());
2899 let db = Arc::new(Baser::new(lmdber).unwrap());
2900
2901 let kevery = Kevery::new(
2902 None,
2903 db,
2904 None,
2905 Some(false),
2906 Some(false),
2907 Some(false),
2908 Some(false),
2909 Some(false),
2910 )
2911 .unwrap();
2912
2913 Handlers {
2914 kevery: Arc::new(Mutex::new(kevery)),
2915 tevery: Arc::new(MockHandler { serder: None }),
2916 exchanger: Arc::new(MockHandler { serder: None }),
2917 revery: Arc::new(MockHandler { serder: None }),
2918 verifier: Arc::new(MockHandler { serder: None }),
2919 local: false,
2920 }
2921 }
2922 }
2923}