Skip to main content

libkeri/keri/core/
parsing.rs

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/// Trans Indexed Sig Groups
22#[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/// Trans Indexed Sig Groups
70#[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
91/// Enum to represent the different types of SadPathGroups
92pub enum SadPathGroup {
93    TransIdxSig(SadTsgs),
94    ControllerIdxSig(SadSigers),
95    NonTransReceipt(SadCigars),
96}
97
98/// Represents all possible parsed messages from a KERI stream that can be processed
99/// by Kevery, Tevery, Exchanger, Revery, or Verifier
100pub enum Message {
101    /// Identifier key event messages
102    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>>, // For process attached receipt couples
111        trqs: Option<Vec<Trqs>>,    // For process attached receipt quadruples
112        local: Option<bool>,
113    },
114
115    /// Non-transferable receipt messages
116    Receipt {
117        serder: Box<SerderKERI>,
118        cigars: Vec<Cigar>,
119        local: Option<bool>,
120    },
121
122    /// Witness receipt messages
123    WitnessReceipt {
124        serder: Box<SerderKERI>,
125        wigers: Vec<Siger>,
126        local: Option<bool>,
127    },
128
129    /// Transferable receipt messages
130    ReceiptTrans {
131        serder: Box<dyn Serder>,
132        tsgs: Vec<Tsgs>,
133        local: Option<bool>,
134    },
135
136    /// Query messages for Kevery or Tevery
137    Query {
138        serder: Box<SerderKERI>,
139        source: Option<Prefixer>,
140        sigers: Option<Vec<Siger>>,
141        cigar: Option<Vec<Cigar>>,
142    },
143
144    /// Reply messages for Revery with non-transferable signatures
145    ReplyNonTrans {
146        serder: Box<dyn Serder>,
147        cigars: Vec<Cigar>,
148    },
149
150    /// Reply messages for Revery with transferable signatures
151    ReplyTrans {
152        serder: Box<dyn Serder>,
153        tsgs: Vec<Tsgs>,
154    },
155
156    /// Event messages for Exchanger with non-transferable signatures
157    ExchangeEventNonTrans {
158        serder: Box<dyn Serder>,
159        cigars: Vec<Cigar>,
160        pathed: Option<Vec<Vec<u8>>>,
161        essrs: Option<Vec<Texter>>,
162    },
163
164    /// Event messages for Exchanger with transferable signatures
165    ExchangeEventTrans {
166        serder: Box<dyn Serder>,
167        tsgs: Vec<Tsgs>,
168        pathed: Option<Vec<Vec<u8>>>,
169        essrs: Option<Vec<Texter>>,
170    },
171
172    /// TEL events for Tevery
173    TELEvent {
174        serder: Box<dyn Serder>,
175        seqner: Option<Seqner>,
176        saider: Option<Saider>,
177        wigers: Option<Vec<Siger>>,
178    },
179
180    /// Credential messages for Verifier
181    Credential {
182        creder: Box<dyn Serder>,
183        prefixer: Option<Prefixer>,
184        seqner: Option<Seqner>,
185        saider: Option<Saider>,
186    },
187}
188
189// Implementation with helper methods
190impl Message {
191    /// Determines if the message is local
192    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// Traits for message handlers
203#[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    /// Whether parsed messages come from a local (protected) source.
218    local: bool,
219    attachment_processing: bool, // Flag to mark if we're in the middle of attachments
220    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    /// Parse one message from a byte array synchronously
234    /// This is the Rust equivalent of Python's parseOne method
235    pub fn parse_one(&mut self, ims: &[u8]) -> Result<(), KERIError> {
236        // Create a temporary buffer with the input message
237        let mut temp_buffer = ims.to_vec();
238
239        // Store current buffer state
240        let original_buffer = std::mem::replace(&mut self.buffer, temp_buffer);
241
242        // Process the message
243        let result = self.try_parse_one_message();
244
245        // Restore original buffer state
246        self.buffer = original_buffer;
247
248        result
249    }
250
251    /// Internal method to process one complete message from the current buffer
252    fn try_parse_one_message(&mut self) -> Result<(), KERIError> {
253        // Parse one message from the buffer
254        match self.try_parse_message() {
255            Ok((message, _consumed)) => {
256                // try_parse_message already drained the consumed bytes
257                self.attachment_processing = false;
258                self.current_serder = None;
259
260                // Process the parsed message
261                self.process_parsed_message(message)?;
262
263                Ok(())
264            }
265            Err(MatterError::NeedMoreDataError(_)) => {
266                // For parseOne, we expect complete messages, so this is an error
267                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    /// Process a parsed message through the appropriate handlers
279    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                // Process event through kevery if available
289                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, // delseqner
295                    None, // delsaider
296                    None, // firner
297                    None, // dater
298                    None, // local
299                    None, // seqner
300                );
301
302                // Handle kevery processing errors appropriately
303                match result {
304                    Ok(_) => {}
305                    Err(KERIError::MissingSignatureError(_)) => {
306                        // Missing signatures are acceptable in some scenarios
307                    }
308                    Err(e) => return Err(e),
309                }
310                Ok(())
311            }
312            Message::Receipt { serder, cigars, .. } => {
313                // Process receipt through kevery
314                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                // Process witness receipt through kevery
320                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                // Process query through kevery
331                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                // Process non-transferable reply through revery handler
337                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                // Process transferable reply through revery handler
343                let msg = Message::ReplyTrans { serder, tsgs };
344                futures::executor::block_on(self.handlers()?.revery.handle(msg))?;
345                Ok(())
346            }
347            _ => {
348                // Other message types - for now just acknowledge
349                Ok(())
350            }
351        }
352    }
353
354    fn try_parse_message(&mut self) -> Result<(Message, usize), MatterError> {
355        // Track if we're in the middle of processing attachments for an already parsed message
356        let processing_attachments = self.attachment_processing && self.buffer.get(0) == Some(&45);
357
358        // Only look for next message if we're not already processing attachments
359        // and the current buffer starts with an attachment marker
360        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        // This block handles the continuation of attachment processing
381        if self.attachment_processing {
382            // Check if we have a stored serder
383            if self.current_serder.is_none() {
384                // Since we can't continue without a serder, we need to reset and try parsing a new message
385                self.attachment_processing = false;
386
387                // Skip any attachment data if we had to reset
388                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                // We have a stored serder, so we can continue processing attachments
405                // Extract the stored serder
406                let serder = self.current_serder.take().unwrap();
407
408                // Initialize collections for attachments
409                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                // Track attachment size
425                let buffer_before_attachments = self.buffer.len();
426
427                // Process attachments
428                while !self.buffer.is_empty() {
429                    if self.buffer[0] == 123 {
430                        // 123 = ASCII '{'
431                        // Found a new message start, stop processing attachments
432                        break;
433                    } else if self.buffer[0] == 45 {
434                        // 45 = ASCII '-'
435                        // Process attachment
436                        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                                                // Calculate expected attachment size
447                                                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                                                    // Still not enough data for attachments
455                                                    // Save the serder again for next attempt
456                                                    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                                                // Process individual attachments
493                                                let mut current_ctr = ctr;
494                                                let mut current_cold = cold;
495
496                                                loop {
497                                                    self.process_attachments(
498                                                        &current_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                                                    // Check if we need to continue with more attachments
518                                                    if self.buffer.is_empty() {
519                                                        break;
520                                                    }
521
522                                                    // If next byte is {, it's a new message
523                                                    if self.buffer[0] == 123 {
524                                                        break;
525                                                    }
526
527                                                    // Try to identify next attachment
528                                                    let new_cold = match sniff(&self.buffer) {
529                                                        Ok(c) => c,
530                                                        Err(e) => break,
531                                                    };
532
533                                                    // If it looks like a message, stop
534                                                    if new_cold == COLDS.msg {
535                                                        break;
536                                                    }
537
538                                                    current_cold = new_cold;
539
540                                                    // Try to extract counter for next attachment
541                                                    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                                    // Found message marker in data that looks like an attachment
558                                    break;
559                                }
560                            }
561                            Err(e) => return Err(e),
562                        }
563                    } else {
564                        // Unexpected data format
565                        return Err(MatterError::ParseError(
566                            "Unexpected data format".to_string(),
567                        ));
568                    }
569                }
570
571                // Calculate attachment size
572                let attachment_size = buffer_before_attachments - self.buffer.len();
573
574                // Process the message with the attachments we've gathered
575                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                // Reset attachment processing state
594                self.attachment_processing = false;
595
596                return Ok((msg, attachment_size));
597            }
598        }
599
600        // This is where we parse the message body (only if we're not already processing attachments)
601        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        // Initialize collections for different attachment types
624        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        // Track attachment size
640        let mut attachment_size = 0;
641        let buffer_before_attachments = self.buffer.len();
642
643        // Process attachments
644        while !self.buffer.is_empty() {
645            if self.buffer[0] == 123 {
646                // 123 = ASCII '{'
647                // Found a new message start, stop processing attachments
648                break;
649            } else if self.buffer[0] == 45 {
650                // 45 = ASCII '-'
651                // Process attachment
652                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                                        // Calculate expected attachment size
663                                        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                                            // Not enough data for attachments
671                                            // Store the current serder for later continuation
672                                            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                                        // Process individual attachments
708                                        let mut current_ctr = ctr;
709                                        let mut current_cold = cold;
710
711                                        loop {
712                                            self.process_attachments(
713                                                &current_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                                            // Check if we need to continue with more attachments
733                                            if self.buffer.is_empty() {
734                                                break;
735                                            }
736
737                                            // If next byte is {, it's a new message
738                                            if self.buffer[0] == 123 {
739                                                break;
740                                            }
741
742                                            // Try to identify next attachment
743                                            let new_cold = match sniff(&self.buffer) {
744                                                Ok(c) => c,
745                                                Err(_) => break,
746                                            };
747
748                                            // If it looks like a message, stop
749                                            if new_cold == COLDS.msg {
750                                                break;
751                                            }
752
753                                            current_cold = new_cold;
754
755                                            // Try to extract counter for next attachment
756                                            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                            // Found message marker in data that looks like an attachment
773                            break;
774                        }
775                    }
776                    Err(e) => return Err(e),
777                }
778            } else {
779                // Unexpected data format
780                return Err(MatterError::ParseError(
781                    "Unexpected data format".to_string(),
782                ));
783            }
784        }
785
786        // Calculate final attachment size
787        attachment_size = buffer_before_attachments - self.buffer.len();
788
789        // Process the message with its attachments
790        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    /// Create a parser with no handlers. It can only extract messages
828    /// (see [`Parser::parse_messages`]); the caller routes them. This is how a
829    /// single owner (e.g. `Habery`) parses without the parser holding shared
830    /// references to its Kevery/Revery.
831    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    /// Parse every complete message in `ims` and return them without
854    /// dispatching to any handler. Errors if `ims` ends mid-message.
855    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            // Same per-message state handling as parse_stream.
863            if self.current_serder.is_none() {
864                self.attachment_processing = false;
865            }
866            match self.try_parse_message() {
867                Ok((message, _consumed)) => {
868                    // try_parse_message already drained the consumed bytes
869                    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    // Helper method to process a single counter and its data
886    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                // Extract receipt couplets into cigars
927                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                    // Extract each attached quadruple
936                    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                // Compute size of pathed material based on txt or bny
1102                let pags = if cold == COLDS.txt {
1103                    ctr.count() * 4
1104                } else {
1105                    ctr.count() * 3
1106                };
1107
1108                // Make sure we have enough data
1109                if self.buffer.len() < pags as usize {
1110                    return Err(MatterError::NeedMoreDataError(
1111                        "Needs more data".to_string(),
1112                    ));
1113                }
1114
1115                // Extract the pathed material
1116                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 message type to handler
1142        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" => {} //self.handlers()?.tevery.handle(msg).await?,
1238                        &_ => {}
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    // This would typically go inside the impl block for Parser
1277    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        // Check if serder is SerderKERI
1296        if let Some(keri_serder) = serder.as_any().downcast_ref::<SerderKERI>() {
1297            let ilk = keri_serder.ilk();
1298
1299            // Check for event messages
1300            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                // Extract firner and dater from the last element of frcs
1307                let (firner, dater) = frcs
1308                    .last()
1309                    .map(|frcs| (Some(frcs.seqner.clone()), Some(frcs.dater.clone())))
1310                    .unwrap_or((None, None));
1311
1312                // Extract delseqner and delsaider from the last element of sscs
1313                let (delseqner, delsaider) = sscs
1314                    .last()
1315                    .map(|sscs| (Some(sscs.seqner.clone()), Some(sscs.saider.clone())))
1316                    .unwrap_or((None, None));
1317
1318                // Validate signatures
1319                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                // Create KeyEvent message
1329                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            // Receipt message
1349            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            // Reply message
1386            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            // Query message
1404            else if ilk == Some(Ilk::Qry) {
1405                // Check for source and signatures
1406                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            // Exchange message
1431            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            // TEL message
1465            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                // Extract seqner and saider from sscs
1473                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        // Check if serder is SerderACDC
1498        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                // default for ACDC
1503                // Extract prefixer, seqner, and saider from ssts
1504                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        // If we get here, something went wrong in the logic above
1539        Err(MatterError::ValidationError(
1540            "Failed to process message".to_string(),
1541        ))
1542    }
1543
1544    /// Returns a Result containing an instance of the provided type T from the input message stream.
1545    ///
1546    /// # Parameters
1547    /// * `ims` - A mutable reference to bytes that can be stripped
1548    /// * `cold` - Stream state indicator (txt or bny)
1549    /// * `abort` - True means abort if bad pipelined frame, False means wait for more data
1550    /// * `gvrsn` - Instance of genera version of CESR code tables
1551    ///
1552    /// # Returns
1553    /// * `Result<T, MatterError>` - Either the successfully parsed instance or an error
1554    ///
1555    /// # Errors
1556    /// * `ColdStartError` - If the stream state is invalid
1557    /// * `ShortageError` - If not enough bytes in stream and abort is true
1558    ///
1559    /// # Type Parameters
1560    /// * `T` - A type that implements the Parsable trait (equivalent to Serder, Counter, Matter, Indexer)
1561    ///
1562    pub fn _extractor<T: Parsable>(
1563        &mut self,
1564        cold: &str,
1565        abort: bool,
1566        _gvrsn: &Versionage,
1567    ) -> Result<T, MatterError> {
1568        // Try parsing until we either succeed or get a shortage error
1569
1570        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                // In Python, this would yield control back to caller
1583                // In Rust, we need to signal that more data is needed
1584                Err(MatterError::NeedMoreDataError(
1585                    "Needs more data".to_string(),
1586                ))
1587            }
1588            Err(err) => Err(err),
1589        };
1590    }
1591
1592    /// Extract sad path signature groups
1593    ///
1594    /// # Parameters
1595    /// * `ctr` - Group type counter
1596    /// * `ims` - Serialized incoming message stream
1597    /// * `root` - Optional root path of this group
1598    /// * `cold` - Next character Coldage type indicator
1599    /// * `pipelined` - Whether to use pipeline processor
1600    ///
1601    /// # Returns
1602    /// * Vector of tuples containing extracted sad path signature groups
1603    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        // Verify that the counter code is SadPathSigGroups
1612        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        // Extract subpath
1621        let mut subpath = self._extractor::<Pather>(cold, pipelined, gvrsn)?;
1622
1623        // Apply root if provided
1624        // TODO: fix this code to match subpath logic in KERIpy
1625        if let Some(_) = root {
1626            subpath = subpath.root();
1627        }
1628
1629        // Extract subcounter
1630        let sctr = self._extractor::<BaseCounter>(cold, pipelined, gvrsn)?;
1631
1632        let mut result = Vec::new();
1633
1634        // Process based on subcounter code
1635        match sctr.code() {
1636            ctr_dex_1_0::TRANS_IDX_SIG_GROUPS => {
1637                // Extract TransIdxSigGroups
1638                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                // Extract ControllerIdxSigs
1657                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                // Extract NonTransReceiptCouples
1673                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    /// Extract attached trans indexed sig groups, each made of:
1696    /// - triple pre+snu+dig plus indexed sig group
1697    /// - pre is pre of signer (endorser) of msg
1698    /// - snu is sn of signer's est evt when signed
1699    /// - dig is dig of signer's est event when signed
1700    /// Followed by counter for ControllerIdxSigs with attached
1701    /// indexed sigs from trans signer (endorser).
1702    ///
1703    /// # Parameters
1704    /// * `ctr` - Group type counter
1705    /// * `ims` - Serialized incoming message stream
1706    /// * `cold` - Next character Coldage type indicator
1707    /// * `pipelined` - Whether to use pipeline processor
1708    ///
1709    /// # Returns
1710    /// * Vector of tuples containing (prefixer, seqner, saider, isigers)
1711    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            // Extract prefixer
1722            let prefixer = self._extractor::<Prefixer>(cold, pipelined, gvrsn)?;
1723
1724            // Extract seqner
1725            let seqner = self._extractor::<Seqner>(cold, pipelined, gvrsn)?;
1726
1727            // Extract saider
1728            let saider = self._extractor::<Saider>(cold, pipelined, gvrsn)?;
1729
1730            // Extract counter for ControllerIdxSigs
1731            let ictr = self._extractor::<BaseCounter>(cold, pipelined, gvrsn)?;
1732
1733            // Verify that the counter code is ControllerIdxSigs
1734            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            // Extract each attached signature
1743            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            // Add the group to our results
1750            groups.push(Tsgs {
1751                prefixer,
1752                seqner,
1753                saider,
1754                sigers: isigers,
1755            });
1756        }
1757
1758        Ok(groups)
1759    }
1760
1761    /// Extract attached receipt couplets into a vector of cigars
1762    /// Verfer property of each cigar is the identifier prefix
1763    /// Cigar itself has the attached signature
1764    ///
1765    /// # Parameters
1766    /// * `ctr` - Counter with count field indicating number of attachments
1767    /// * `ims` - Input stream containing serialized message data
1768    /// * `cold` - Character coldage type indicator
1769    /// * `pipelined` - Whether to use pipeline processor for stream
1770    ///
1771    /// # Returns
1772    /// * Vector of Cigar objects with attached verfers
1773    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            // Extract verfer
1784            let verfer = self._extractor::<Verfer>(cold, pipelined, gvrsn)?;
1785
1786            // Extract cigar
1787            let mut cigar = self._extractor::<Cigar>(cold, pipelined, gvrsn)?;
1788
1789            // Attach verfer to cigar
1790            cigar.verfer = Some(verfer);
1791
1792            // Add to results
1793            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); // 30 second timeout
1805        let start_time = Instant::now();
1806
1807        // Track if we need to force a read due to incomplete message
1808        let mut force_read = false;
1809        // Track EOF status
1810        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            // Read more data if:
1825            // 1. This is the first read, or
1826            // 2. Buffer is below threshold, or
1827            // 3. We need to force a read due to incomplete message
1828            if first_read || self.buffer.len() < 100 || force_read {
1829                first_read = false;
1830                force_read = false; // Reset force_read flag
1831
1832                // Read data asynchronously into buffer
1833                let mut chunk = vec![0u8; 8192]; // Increased from 4096 to handle larger messages
1834
1835                let n = self.reader.read(&mut chunk).await?;
1836                if n == 0 {
1837                    // We've reached EOF
1838                    reached_eof = true;
1839
1840                    if self.buffer.is_empty() {
1841                        break;
1842                    }
1843                    // If we have data in buffer but hit EOF, we'll try to parse once more
1844                } else {
1845                    // Successfully read more data
1846                    self.buffer.extend_from_slice(&chunk[..n]);
1847                }
1848            }
1849
1850            let mut made_progress = false;
1851            loop {
1852                // Check if we're in the middle of processing attachments
1853                if self.attachment_processing && self.buffer.get(0) == Some(&45) {
1854                    // We need to use the stored serder and attachment state
1855                    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                        // Reset attachment processing state
1865                        self.attachment_processing = false;
1866                        self.current_serder = None;
1867
1868                        // Try to dispatch the message but ignore validation errors
1869                        if let Err(e) = self.dispatch_message(msg).await {
1870                            match e {
1871                                // Only ignore ValidationErrors, propagate other errors
1872                                KERIError::ValidationError(_) => {}
1873                                KERIError::OutOfOrderError(msg) => {
1874                                    // For diagnostic purposes, continue processing despite out-of-order events
1875                                    if !msg.contains("Diagnostic") {}
1876                                }
1877                                _ => {
1878                                    return Err(e);
1879                                }
1880                            }
1881                        }
1882                    }
1883                    Err(e) => {
1884                        // Check if we need more data
1885                        if let MatterError::NeedMoreDataError(msg) = &e {
1886                            // Check if this is an attachment processing error
1887                            if msg.contains("Not enough data for attachments")
1888                                && !self.buffer.is_empty()
1889                                && self.buffer[0] == 45
1890                            {
1891                                // Set attachment processing flag
1892                                self.attachment_processing = true;
1893                            }
1894
1895                            if reached_eof {
1896                                // If we're at EOF but need more data, we have an incomplete message
1897                                // Reset attachment processing state since we're at EOF
1898                                self.attachment_processing = false;
1899                                self.current_serder = None;
1900
1901                                // At EOF with incomplete message - clear buffer and break
1902                                self.buffer.clear();
1903                                break;
1904                            } else {
1905                                // We need more data and haven't hit EOF yet - force another read
1906                                force_read = true;
1907                                break;
1908                            }
1909                        } else {
1910                            // Some other parsing error
1911                            // Reset attachment processing state on general errors
1912                            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                    // Reset attachment processing state when buffer is empty
1921                    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                // Reset attachment processing state at EOF
1937                self.attachment_processing = false;
1938                self.current_serder = None;
1939
1940                // Clear any remaining buffer at EOF
1941                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        // 20-event KEL: every message is a key event with signatures.
1971        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        // keripy witness OOBI response: icp, then 3 replies signed by the witness.
1980        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        // A parser without handlers refuses to dispatch.
1989        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        // Set up to read the test KEL file
2001        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
2002        path.push("src/resources/20-evt.cesr");
2003
2004        // Read the KEL file
2005        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        // Create a temporary database for the test
2015        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        // Create an explicit Kevery instance with more relaxed settings
2020        let kevery = Kevery::new(
2021            None,        // No recovery module
2022            db.clone(),  // Database reference
2023            None,        // Default cues
2024            Some(true),  // lax mode - set to true to be more forgiving
2025            Some(false), // local mode
2026            Some(false), // cloned mode
2027            Some(false), // direct mode
2028            Some(false), // check mode
2029        )?;
2030
2031        // Use the simpler approach with just the Kevery handler
2032        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        // Create a parser with the handlers, set debug to true for more info
2042        let mut parser = Parser::new(reader, true, false, handlers);
2043
2044        // Parse the KEL file
2045        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        // Get the identifier from the first event in our KEL file
2053        let identifier = "EIryzWYlZ9bQr7EhMAoBXk4r2h-OgaEqERid7-AHNp6o";
2054
2055        // Query the database for events with this identifier
2056        let msgs = db.clone_pre_iter(identifier, None)?;
2057
2058        // Assert that we found events
2059        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        // Process all events into typed events
2071        let events = msgs
2072            .iter()
2073            .map(|msg| SerderKERI::from_raw(msg, None))
2074            .collect::<Result<Vec<_>, _>>()?;
2075
2076        // Validate the number of events
2077        assert_eq!(
2078            events.len(),
2079            20,
2080            "Expected exactly 100 events in the KEL file"
2081        );
2082
2083        // Validate the first event (inception event)
2084        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        // Check the key configuration of the inception event
2097        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        // Check next threshold and next keys
2108        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        // Validate the second event (rotation)
2122        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        // Verify previous digest reference is correct
2135        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        // Verify key rotation occurred
2142        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        // Verify sequence continuity for all events
2150        for i in 1..events.len() {
2151            let curr = &events[i];
2152            let prev = &events[i - 1];
2153
2154            // Check that sequence numbers increment correctly (hex values)
2155            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            // Check proper chaining via previous digest field
2168            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        // Check correct rotation of the signing keys
2179        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                // Check if keys have changed in rotation events
2185                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        // Check event type distribution
2202        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        // Check for any interaction events with anchors in them
2224        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        // Test completed successfully
2240        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        // Provide CESR-encoded message bytes matching KERIpy tests
2267        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        // Create a temporary database
2274        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        // Create Kevery using the builder pattern
2283        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        // Create signers
2321        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        // Create databases
2328        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        // Create sig counter
2344        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        // Sign serialization
2352        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        // Create key event verifier state
2360        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        // Extend key event stream
2378        msgs.extend_from_slice(&serder.raw());
2379        msgs.extend_from_slice(&counter.qb64b());
2380        msgs.extend_from_slice(&siger.qb64b());
2381
2382        // Event 1: Rotation Transferable
2383        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        // Create sig counter
2397        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        // Sign serialization
2403        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        // Extend key event stream
2424        msgs.extend_from_slice(&serder.raw());
2425        msgs.extend_from_slice(&counter.qb64b());
2426        msgs.extend_from_slice(&siger.qb64b());
2427
2428        // Event 2: Rotation Transferable
2429        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        // Create sig counter
2442        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        // Sign serialization
2450        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        // Update key event verifier state
2458        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        // Extend key event stream
2473        msgs.extend_from_slice(&serder.raw());
2474        msgs.extend_from_slice(&counter.qb64b());
2475        msgs.extend_from_slice(&siger.qb64b());
2476
2477        // Event 3: Interaction
2478        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        // Create sig counter
2489        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        // Sign serialization
2497        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        // Update key event verifier state
2505        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        // Extend key event stream
2520        msgs.extend_from_slice(&serder.raw());
2521        msgs.extend_from_slice(&counter.qb64b());
2522        msgs.extend_from_slice(&siger.qb64b());
2523
2524        // Event 4: Interaction
2525        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        // Create sig counter
2536        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        // Sign serialization
2543        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        // Update key event verifier state
2551        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        // Extend key event stream
2566        msgs.extend_from_slice(&serder.raw());
2567        msgs.extend_from_slice(&counter.qb64b());
2568        msgs.extend_from_slice(&siger.qb64b());
2569
2570        // Event 5: Rotation Transferable
2571        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        // Create sig counter
2584        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        // Sign serialization
2592        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        // Update key event verifier state
2600        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        // Extend key event stream
2615        msgs.extend_from_slice(&serder.raw());
2616        msgs.extend_from_slice(&counter.qb64b());
2617        msgs.extend_from_slice(&siger.qb64b());
2618
2619        // Event 6: Interaction
2620        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        // Create sig counter
2630        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        // Sign serialization
2637        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        // Update key event verifier state
2645        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        // Extend key event stream
2660        msgs.extend_from_slice(&serder.raw());
2661        msgs.extend_from_slice(&counter.qb64b());
2662        msgs.extend_from_slice(&siger.qb64b());
2663
2664        // Event 7: Rotation to null NonTransferable Abandon
2665        // nxt digest is empty (no ndigs)
2666        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            // ndigs is intentionally empty - this makes the key non-transferable
2674            .with_ndigs(vec![])
2675            .build()?;
2676
2677        event_digs.push(serder.said().unwrap());
2678
2679        // Create sig counter
2680        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        // Sign serialization
2687        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        // Update key event verifier state
2695        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        // Extend key event stream
2710        msgs.extend_from_slice(&serder.raw());
2711        msgs.extend_from_slice(&counter.qb64b());
2712        msgs.extend_from_slice(&siger.qb64b());
2713
2714        // Event 8: Interaction but already abandoned
2715        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        // Create sig counter
2724        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        // Sign serialization
2732        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        // Update key event verifier state - should fail because abandoned
2740        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        // Extend key event stream anyway
2757        msgs.extend_from_slice(&serder.raw());
2758        msgs.extend_from_slice(&counter.qb64b());
2759        msgs.extend_from_slice(&siger.qb64b());
2760
2761        // Event 8: Rotation override interaction but already abandoned
2762        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        // Create sig counter
2774        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        // Sign serialization
2782        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        // Update key event verifier state - should fail because nontransferable
2790        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        // Extend key event stream anyway
2807        msgs.extend_from_slice(&serder.raw());
2808        msgs.extend_from_slice(&counter.qb64b());
2809        msgs.extend_from_slice(&siger.qb64b());
2810
2811        // Assert message length
2812        assert_eq!(msgs.len(), 3745);
2813
2814        let pre = kever.prefixer().unwrap().qb64();
2815
2816        // Check db digs
2817        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        // Create Kevery and Parser
2829        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        // Parse the messages
2852        assert!(parser.parse_stream(Some(true)).await.is_ok());
2853
2854        // Check parsed results
2855        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        // let vkever = (parser.handlers.as_ref().unwrap().kevery.lock().await).kevers()[&pre].clone();
2866        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        // Check val_db digs
2877        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        // Test parser without kevery
2889        // Mock a parser with no handlers
2890        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        // Cleanup should be automatic because we're using temp databases
2894        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}