Skip to main content

libkeri/keri/core/eventing/
kever.rs

1use crate::cesr::dater::Dater;
2use crate::cesr::diger::Diger;
3use crate::cesr::indexing::siger::Siger;
4use crate::cesr::indexing::Indexer;
5use crate::cesr::number::Number;
6use crate::cesr::prefixer::Prefixer;
7use crate::cesr::saider::Saider;
8use crate::cesr::seqner::Seqner;
9use crate::cesr::tholder::{Tholder, TholderSith};
10use crate::cesr::trait_dex;
11use crate::cesr::verfer::Verfer;
12use crate::keri::core::eventing::state::StateEventBuilder;
13use crate::keri::core::eventing::verify_sigs;
14use crate::keri::core::eventing::kevery::Locals;
15use crate::keri::core::serdering::{Rawifiable, SadValue, Serder, SerderKERI};
16use crate::keri::db::basing::{Baser, EventSourceRecord, KeyStateRecord, StateEERecord};
17use crate::keri::db::dbing::keys::{dg_key, sn_key};
18use crate::keri::{Ilk, KERIError};
19use crate::Matter;
20use num_bigint::BigUint;
21use std::collections::HashSet;
22use std::sync::Arc;
23
24/// Represents the location of the last establishment event
25#[derive(Debug, Clone, PartialEq)]
26pub struct LastEstLoc {
27    /// Sequence number
28    pub s: u64,
29    /// Digest (said)
30    pub d: String,
31}
32
33pub struct Kever {
34    pub db: Arc<Baser>,
35    version: String,            // Version of KERI protocol
36    ilk: Ilk,                   // Event type ilk
37    pub delpre: Option<String>, // Delegator prefix if any
38    pub(crate) delegated: bool, // True if delegated event, False otherwise
39    fner: Option<Number>,       // First seen ordinal number
40    dater: Option<Dater>,       // First seen timestamp
41
42    // Fields needed for inception
43    pub(crate) sner: Option<Number>,
44    pub verfers: Option<Vec<Verfer>>,
45    tholder: Option<Tholder>,
46    pub(crate) prefixer: Option<Prefixer>,
47    pub(crate) serder: Option<SerderKERI>,
48    pub ndigers: Option<Vec<Diger>>,
49    pub(crate) ntholder: Option<Tholder>,
50    cuts: Option<Vec<String>>,
51    adds: Option<Vec<String>>,
52    pub(crate) wits: Option<Vec<String>>,
53    toader: Option<Number>,
54    last_est: Option<LastEstLoc>,
55
56    // Configuration traits
57    est_only: Option<bool>,
58    do_not_delegate: Option<bool>,
59}
60
61impl Kever {
62    /// Create a new Kever instance for an inception event
63    ///
64    /// # Arguments
65    ///
66    /// * `state` - Optional key state record
67    /// * `serder` - Optional serialized event data
68    /// * `sigers` - Optional list of indexed controller signatures
69    /// * `wigers` - Optional list of indexed witness signatures
70    /// * `db` - LMDB database instance
71    /// * `est_only` - Optional boolean, True means establishment only events allowed
72    /// * `delseqner` - Optional delegating event sequence number
73    /// * `delsaider` - Optional delegating event SAID
74    /// * `firner` - Optional first seen ordinal number
75    /// * `dater` - Optional first seen timestamp
76    /// * `cues` - Optional queue for notices or requests
77    /// * `eager` - Optional boolean for eager validation
78    /// * `local` - Optional boolean for event source validation logic
79    /// * `check` - Optional boolean for database update control
80    ///
81    /// # Returns
82    ///
83    /// * `Result<Self, KERIError>` - New Kever instance or error
84    pub fn new(
85        db: Arc<Baser>,
86        locals: &Locals,
87        state: Option<KeyStateRecord>,
88        serder: Option<SerderKERI>,
89        sigers: Option<Vec<Siger>>,
90        wigers: Option<Vec<Siger>>,
91        est_only: Option<bool>,
92        delseqner: Option<Seqner>,
93        delsaider: Option<Saider>,
94        firner: Option<Seqner>,
95        dater: Option<Dater>,
96        eager: Option<bool>,
97        local: Option<bool>,
98        check: Option<bool>,
99    ) -> Result<Self, KERIError> {
100        // Validate required arguments
101        if state.is_none() && (serder.is_none() || sigers.is_none()) {
102            return Err(KERIError::ValueError(
103                "Missing required arguments. Need state or serder and sigers".to_string(),
104            ));
105        }
106
107        // Default values
108        let eager = eager.unwrap_or(false);
109        let local = local.unwrap_or(true);
110        let check = check.unwrap_or(false);
111
112        if let Some(state) = state {
113            // Preload from state
114            return Self::reload(db, state);
115        }
116
117        // Unwrap serder since we know it exists at this point
118        let serder = serder.unwrap();
119        let sigers = sigers.unwrap();
120
121        // Get version and validate
122        let version = serder.version().clone();
123
124        // Get ilk and validate
125        let ilk = serder.ilk().unwrap().clone();
126        if ilk != Ilk::Icp && ilk != Ilk::Dip {
127            return Err(KERIError::ValidationError(format!(
128                "Expected ilk = icp or dip, got {} for evt = {:?}",
129                ilk,
130                serder.ked()
131            )));
132        }
133
134        // Create Kever with basic fields
135        let mut kever = Kever {
136            db,
137            version: format!("{}", version),
138            ilk,
139            delpre: None,
140            delegated: false,
141            fner: None,
142            dater: None,
143            sner: None,
144            verfers: None,
145            tholder: None,
146            prefixer: None,
147            serder: None,
148            ndigers: None,
149            ntholder: None,
150            cuts: None,
151            adds: None,
152            wits: None,
153            toader: None,
154            last_est: None,
155            est_only: None,
156            do_not_delegate: None,
157            // Initialize other fields here
158        };
159
160        // Do major event validation and state setting
161        kever.incept(serder.clone())?;
162
163        // Assign config traits perms
164        kever.config(serder.clone(), est_only)?;
165
166        // Validates signers, delegation if any, and witnessing when applicable
167        let (sigers, wigers, delpre, delseqner, delsaider) = kever.val_sigs_wigs_del(locals,
168            serder.clone(),
169            sigers,
170            serder.verfers().clone(),
171            kever.tholder().unwrap(),
172            wigers,
173            kever.toader(),
174            kever.wits().clone(),
175            delseqner,
176            delsaider,
177            eager,
178            local,
179        )?;
180
181        // Set delegation fields
182        kever.delpre = delpre;
183        kever.delegated = kever.delpre.is_some();
184
185        // Get witnesses from serder
186        let wits = serder.backs().clone();
187
188        // Log event and get first seen data
189        let (fn_num, dts) = kever.log_event(locals,
190            serder, sigers, wigers, wits, !check, delseqner, delsaider, firner, dater, local,
191        )?;
192
193        // Set first seen data if not in check mode
194        if let Some(fn_num) = fn_num {
195            kever.fner = Some(Number::from_num(&BigUint::from(fn_num))?);
196            kever.dater = Some(Dater::from_dt(dts));
197            let _ = kever
198                .db
199                .states
200                .pin(&[kever.prefixer().unwrap().qb64()], &kever.state()?);
201        }
202
203        Ok(kever)
204    }
205
206    /// Reload Kever attributes (aka its state) from state (KeyStateRecord)
207    ///
208    /// # Arguments
209    ///
210    /// * `state` - Instance of KeyStateRecord containing key state information
211    ///
212    /// # Returns
213    ///
214    /// * `Result<Self, KERIError>` - New Kever instance initialized from state or error
215    pub fn reload(db: Arc<Baser>, state: KeyStateRecord) -> Result<Self, KERIError> {
216        // Create a Prefixer from the identifier prefix
217        let prefixer = Prefixer::from_qb64(&state.i)
218            .map_err(|e| KERIError::ValueError(format!("Invalid identifier prefix: {}", e)))?;
219
220        // Create sequence number from hexadecimal string
221        let sner = Number::from_numh(&state.s)
222            .map_err(|e| KERIError::ValueError(format!("Invalid sequence number: {}", e)))?;
223
224        // Create first seen ordinal number from hexadecimal string
225        let fner = Number::from_numh(&state.f)
226            .map_err(|e| KERIError::ValueError(format!("Invalid first seen number: {}", e)))?;
227
228        // Create datetime stamp — try parsing as DateTime, fall back to from_dts for KERI format
229        let dater = if let Ok(dt) = state.dt.parse::<chrono::DateTime<chrono::Utc>>() {
230            Dater::from_dt(dt)
231        } else {
232            Dater::from_dts(&state.dt).map_err(|e| {
233                KERIError::ValueError(format!("Invalid datetime '{}': {}", state.dt, e))
234            })?
235        };
236
237        // Get event type (ilk)
238        let ilk = match Ilk::from_str(&state.et) {
239            Some(i) => i,
240            None => {
241                return Err(KERIError::ValueError(format!(
242                    "Invalid event type: {}",
243                    state.et
244                )))
245            }
246        };
247
248        // Create signing threshold holder
249        let tholder = Tholder::new(
250            None,
251            None,
252            Some(TholderSith::from_sad_value(SadValue::String(state.kt))?),
253        )?;
254
255        // Create next threshold holder
256        let ntholder = Tholder::new(
257            None,
258            None,
259            Some(TholderSith::from_sad_value(SadValue::String(state.nt))?),
260        )?;
261
262        // Create verifiers from signing keys
263        let verfers = state
264            .k
265            .iter()
266            .map(|key| Verfer::from_qb64(key))
267            .collect::<Result<Vec<Verfer>, _>>()
268            .map_err(|e| KERIError::ValueError(format!("Invalid signing key: {}", e)))?;
269
270        // Create digers from next keys
271        let ndigers = state
272            .n
273            .iter()
274            .map(|dig| Diger::from_qb64(dig))
275            .collect::<Result<Vec<Diger>, _>>()
276            .map_err(|e| {
277                KERIError::ValueError(format!("Invalid next signing key digest: {}", e))
278            })?;
279
280        // Create witness threshold
281        let toader = Number::from_numh(&state.bt)
282            .map_err(|e| KERIError::ValueError(format!("Invalid witness threshold: {}", e)))?;
283
284        // Get witnesses
285        let wits = state.b.clone();
286
287        // Get cuts and adds from establishment event record
288        let cuts = state.ee.br.clone().unwrap_or_default();
289        let adds = state.ee.ba.clone().unwrap_or_default();
290
291        // Create configuration traits
292        let est_only = state.c.contains(&"EstOnly".to_string());
293        let do_not_delegate = state.c.contains(&"DoNotDelegate".to_string());
294
295        // Create last establishment event location
296        let last_est_sn = u64::from_str_radix(&state.ee.s, 16).map_err(|e| {
297            KERIError::ValueError(format!("Invalid last establishment sequence number: {}", e))
298        })?;
299
300        let last_est = LastEstLoc {
301            s: last_est_sn,
302            d: state.ee.d.clone(),
303        };
304
305        // Get delegator prefix if any
306        let delpre = if state.di.is_empty() {
307            None
308        } else {
309            Some(state.di.clone())
310        };
311        let delegated = delpre.is_some();
312
313        // In a complete implementation, the code below would retrieve the event from the database
314        // and create the serder, then construct and return the Kever
315
316        // Get the corresponding event from the database
317        let key = dg_key(prefixer.qb64(), state.d.clone());
318
319        let raw = match db.evts.get::<_, Vec<u8>>(&[key]) {
320            Ok(Some(data)) => data,
321            _ => {
322                return Err(KERIError::DatabaseError(format!(
323                    "Corresponding event not found for state={:?}",
324                    prefixer.qb64()
325                )))
326            }
327        };
328
329        // Create SerderKERI from raw bytes
330        let serder = SerderKERI::from_raw(&raw, None)
331            .map_err(|e| KERIError::ValueError(format!("Invalid event serder: {}", e)))?;
332
333        // Create and return Kever instance with all components
334        Ok(Kever {
335            db,
336            version: format!("{}.{}", state.vn[0], state.vn[1]), // Convert version numbers to string
337            ilk,
338            delpre,
339            delegated,
340            fner: Some(fner),
341            dater: Some(dater),
342            sner: Some(sner),
343            verfers: Some(verfers),
344            tholder: Some(tholder),
345            prefixer: Some(prefixer),
346            serder: Some(serder),
347            ndigers: Some(ndigers),
348            ntholder: Some(ntholder),
349            cuts: Some(cuts),
350            adds: Some(adds),
351            wits: Some(wits),
352            toader: Some(toader),
353            last_est: Some(last_est),
354            est_only: Some(est_only),
355            do_not_delegate: Some(do_not_delegate),
356        })
357    }
358
359    /// Verify inception key event message from serder
360    ///
361    /// # Arguments
362    ///
363    /// * `serder` - SerderKERI instance of inception event
364    ///
365    /// # Returns
366    ///
367    /// * `Result<(), KERIError>` - Success or error
368    fn incept(&mut self, serder: SerderKERI) -> Result<(), KERIError> {
369        // Get event data
370        let ked = serder.sad();
371
372        // Check sequence number
373        let sner = serder.sner().ok_or_else(|| {
374            KERIError::ValidationError("Missing sequence number in inception event".to_string())
375        })?;
376
377        // Ensure sequence number is 0 for inception
378        if sner.num() > 0 {
379            return Err(KERIError::ValidationError(format!(
380                "Nonzero sn={} in inception event.",
381                sner.num()
382            )));
383        }
384
385        // Get and validate verifiers
386        let verfers = serder.verfers().ok_or_else(|| {
387            KERIError::ValidationError("Missing verifiers in inception event".to_string())
388        })?;
389
390        // Get and validate threshold holder
391        let tholder = serder.tholder().ok_or_else(|| {
392            KERIError::ValidationError("Missing threshold in inception event".to_string())
393        })?;
394
395        // Check if threshold size is valid for number of keys
396        if verfers.len() < tholder.size() {
397            return Err(KERIError::ValidationError(format!(
398                "Invalid sith = {:?} for keys = {:?} for evt = {:?}.",
399                tholder.sith(),
400                verfers.iter().map(|v| v.qb64()).collect::<Vec<String>>(),
401                ked
402            )));
403        }
404
405        // Extract and validate prefixer
406        let prefixer = Prefixer::from_qb64(&serder.pre().unwrap())?;
407
408        // Get and validate next digest list
409        let ndigs = serder.ndigs().unwrap_or_default();
410        if !prefixer.transferable() && !ndigs.is_empty() {
411            return Err(KERIError::ValidationError(
412                format!("Invalid inception next digest list not empty for non-transferable prefix = {} for evt = {:?}.",
413                        prefixer.qb64(), ked)
414            ));
415        }
416
417        // Get next digest verifiers
418        let ndigers = serder.ndigers().unwrap_or_default();
419
420        // Get next threshold holder
421        let ntholder = serder.ntholder();
422
423        // Cuts and adds are always empty at inception since no previous event
424        let cuts: Vec<String> = Vec::new();
425        let adds: Vec<String> = Vec::new();
426
427        // Get and validate witnesses
428        let wits = serder.backs().unwrap_or_default();
429
430        if !prefixer.transferable() && !wits.is_empty() {
431            return Err(KERIError::ValidationError(format!(
432                "Invalid inception wits not empty for non-transferable prefix = {} for evt = {:?}.",
433                prefixer.qb64(),
434                ked
435            )));
436        }
437
438        // Check for duplicate witnesses
439        let mut unique_wits = HashSet::new();
440        for wit in &wits {
441            if !unique_wits.insert(wit) {
442                return Err(KERIError::ValidationError(format!(
443                    "Invalid backers = {:?}, has duplicates for evt = {:?}.",
444                    wits, ked
445                )));
446            }
447        }
448
449        // Get and validate toad (threshold of accountable duplicity)
450        let sad = serder.sad();
451        let bt_hex = sad.get("bt").and_then(|v| v.as_str()).ok_or_else(|| {
452            KERIError::ValidationError("Missing bt in inception event".to_string())
453        })?;
454
455        let toader = Number::from_num(&BigUint::from(
456            u64::from_str_radix(bt_hex, 16)
457                .map_err(|e| KERIError::ValueError(format!("Invalid hex in ion: {}", e)))?,
458        ))?;
459        let toad_num = toader.num() as usize;
460
461        if !wits.is_empty() {
462            if toad_num < 1 || toad_num > wits.len() {
463                return Err(KERIError::ValueError(format!(
464                    "Invalid toad = {} for backers (wits)={:?} for event={:?}.",
465                    toad_num, wits, ked
466                )));
467            }
468        } else {
469            if toad_num != 0 {
470                return Err(KERIError::ValueError(format!(
471                    "Invalid toad = {} for backers (wits)={:?} for event={:?}.",
472                    toad_num, wits, ked
473                )));
474            }
475        }
476
477        // Check data field for non-transferable prefixes
478        // keripy: `if not transferable and serder.ked["a"]` (rejects only non-empty data)
479        let data_nonempty = match serder.sad().get("a") {
480            None => false,
481            Some(SadValue::Array(v)) => !v.is_empty(),
482            Some(SadValue::Object(m)) => !m.is_empty(),
483            Some(SadValue::String(s)) => !s.is_empty(),
484            Some(_) => true,
485        };
486        if !prefixer.transferable() && data_nonempty {
487            return Err(KERIError::ValidationError(format!(
488                "Invalid inception data not empty for non-transferable prefix = {} for evt = {:?}.",
489                prefixer.qb64(),
490                ked
491            )));
492        }
493
494        // Last establishment event location (needed for recovery events and transferable receipts)
495        let last_est = LastEstLoc {
496            s: sner.num() as u64,
497            d: serder.said().unwrap_or_default().to_string(),
498        };
499
500        // Store all the validated fields into the Kever instance
501        self.sner = Some(sner);
502        self.verfers = Some(verfers);
503        self.tholder = Some(tholder);
504        self.prefixer = Some(prefixer);
505        self.serder = Some(serder.clone());
506        self.ndigers = Some(ndigers);
507        self.ntholder = ntholder;
508        self.cuts = Some(cuts);
509        self.adds = Some(adds);
510        self.wits = Some(wits);
511        self.toader = Some(toader);
512        self.last_est = Some(last_est);
513
514        Ok(())
515    }
516
517    /// Process configuration traits from the serder
518    ///
519    /// # Arguments
520    ///
521    /// * `serder` - The SerderKERI containing configuration traits
522    /// * `est_only` - Optional boolean to override the EstOnly trait setting
523    ///
524    /// # Returns
525    ///
526    /// * `Result<(), KERIError>` - Success or error
527    fn config(&mut self, serder: SerderKERI, est_only: Option<bool>) -> Result<(), KERIError> {
528        // We need to add these fields to the Kever struct
529        // Add constants for default values
530        const EST_ONLY: bool = false;
531        const DO_NOT_DELEGATE: bool = false;
532
533        // Assign traits with proper default values
534        // Use provided est_only if available, otherwise use default or current value
535        self.est_only = match est_only {
536            Some(value) => Some(value),
537            None => Some(self.est_only.unwrap_or(EST_ONLY)),
538        };
539
540        // For do_not_delegate, we'll use the current value or default
541        self.do_not_delegate = Some(self.do_not_delegate.unwrap_or(DO_NOT_DELEGATE));
542
543        // Process configuration traits from the serder
544        if let Some(traits) = serder.traits() {
545            // In Rust we need to check the type of traits and process accordingly
546            if let Some(traits_array) = traits.as_array() {
547                // Process each trait in the array
548                for trait_value in traits_array {
549                    if let Some(trait_str) = trait_value.as_str() {
550                        match trait_str {
551                            // Using string literals here, but should use proper TraitDex enum
552                            "EO" => self.est_only = Some(true),
553                            "DND" => self.do_not_delegate = Some(true),
554                            _ => (), // Ignore unknown traits
555                        }
556                    }
557                }
558            }
559        }
560
561        Ok(())
562    }
563
564    /// Validates signatures, witnesses, and delegation
565    ///
566    /// Returns tuple (sigers, wigers, delpre, delseqner, delsaider) where:
567    /// - sigers: Vec of validated signature verified members of input sigers
568    /// - wigers: Option<Vec> of validated signature verified members of input wigers
569    /// - delpre: Option<String> delegator prefix if delegated else None
570    /// - delseqner: Option<Seqner> delegating event sequence number
571    /// - delsaider: Option<Saider> delegating event SAID
572    ///
573    /// # Arguments
574    ///
575    /// * `serder` - Serialized event data
576    /// * `sigers` - List of indexed controller signatures
577    /// * `verfers` - List of verifiers from latest est event
578    /// * `tholder` - Threshold holder for signatures
579    /// * `wigers` - Optional list of indexed witness signatures
580    /// * `toader` - Optional threshold holder for witnesses
581    /// * `wits` - List of witness prefixes
582    /// * `delseqner` - Optional delegating event sequence number
583    /// * `delsaider` - Optional delegating event SAID
584    /// * `eager` - Boolean for eager validation
585    /// * `local` - Boolean for event source validation logic
586    fn val_sigs_wigs_del(
587        &self,
588        locals: &Locals,
589        serder: SerderKERI,
590        mut sigers: Vec<Siger>,
591        verfers: Option<Vec<Verfer>>,
592        tholder: Tholder,
593        wigers: Option<Vec<Siger>>,
594        toader: Option<Number>,
595        wits: Vec<String>,
596        delseqner: Option<Seqner>,
597        delsaider: Option<Saider>,
598        eager: bool,
599        local: bool,
600    ) -> Result<
601        (
602            Vec<Siger>,
603            Option<Vec<Siger>>,
604            Option<String>,
605            Option<Seqner>,
606            Option<Saider>,
607        ),
608        KERIError,
609    > {
610        // Unwrap verfers since they are required
611        let verfers = match verfers {
612            Some(v) => v,
613            None => return Err(KERIError::ValueError("Missing verfers".to_string())),
614        };
615
616        // Unwrap toader or use default if None
617        let toader = match toader {
618            Some(t) => t,
619            None => Number::from_num(&BigUint::from(0u32))?,
620        };
621
622        // Check threshold vs number of keys
623        if verfers.len() < tholder.size() {
624            return Err(KERIError::ValidationError(format!(
625                "Invalid sith = {:?} for keys = {:?} for evt = {:?}",
626                tholder.sith(),
627                verfers.iter().map(|v| v.qb64()).collect::<Vec<String>>(),
628                serder.ked()
629            )));
630        }
631
632        // Filter sigers for locally membered signatures when not local
633        if !local && self.locally_membered(locals, None) {
634            if let Some(indices) = self.locally_contributed_indices(&verfers) {
635                sigers = sigers
636                    .into_iter()
637                    .filter(|siger| !indices.contains(&siger.index()))
638                    .collect();
639
640                // TODO: Implement cue pushing for remoteMemberedSig if needed
641            }
642        }
643
644        // Verify signatures and get unique verified sigers and indices
645        let (sigers, indices) = verify_sigs(&serder.raw(), sigers, &verfers)?;
646
647        // Check if minimally signed
648        if indices.is_empty() {
649            return Err(KERIError::ValidationError(format!(
650                "No verified signatures for evt = {:?}",
651                serder.ked()
652            )));
653        }
654
655        // Get delegator's delpre if any for misfit check
656        let delpre = if serder.ilk() == Some(Ilk::Dip) {
657            // Get delegator from dip event
658            let delpre = serder.delpre();
659            if delpre.is_none() {
660                return Err(KERIError::ValidationError(format!(
661                    "Empty or missing delegator for delegated inception event = {:?}",
662                    serder.ked()
663                )));
664            }
665            delpre
666        } else if serder.ilk() == Some(Ilk::Drt) {
667            // Get delegator from kever state
668            self.delpre.clone()
669        } else {
670            // Not delegable event (icp, rot, ixn)
671            None
672        };
673
674        // Misfit escrow checks
675        if !local
676            && (self.locally_owned(locals, None)
677                || self.locally_witnessed(locals, Some(&wits), None)
678                || self.locally_delegated(locals, delpre.as_deref()))
679        {
680            self.escrow_mf_event(
681                &serder,
682                sigers,
683                wigers,
684                delseqner.as_ref(),
685                delsaider.as_ref(),
686                local,
687            )?;
688
689            return Err(KERIError::MisfitEventSourceError(format!(
690                "Nonlocal source for locally owned or locally witnessed or locally delegated event={:?}, local aids={:?}, wits={:?}, delegator={:?}",
691                serder.ked(),
692                locals.prefixes,
693                wits,
694                delpre
695            )));
696        }
697
698        // Convert witness prefixes to verifiers
699        let werfers: Vec<Verfer> = wits
700            .iter()
701            .map(|wit| Verfer::from_qb64(wit))
702            .collect::<Result<Vec<Verfer>, _>>()?;
703
704        // Verify witness signatures
705        let (wigers, windices) = match wigers {
706            Some(wigers) => {
707                let (wigers, windices) = verify_sigs(&serder.raw(), wigers, &werfers)?;
708                (Some(wigers), windices)
709            }
710            None => (None, vec![]),
711        };
712
713        // Check if fully signed vs signing threshold
714        let pre = self.prefixer().unwrap().qb64();
715        if !tholder.satisfy(&indices) {
716            // Escrow partially signed event
717            self.escrow_ps_event(
718                &serder,
719                sigers.clone(),
720                wigers,
721                delseqner.as_ref(),
722                delsaider.as_ref(),
723                local,
724            )?;
725
726            return Err(KERIError::MissingSignatureError(format!(
727                "AID {}...{}: Failure satisfying sith = {:?} on sigs {:?} for evt = {:?}",
728                &pre[..4],
729                &pre[pre.len() - 4..],
730                tholder.sith(),
731                sigers.iter().map(|s| s.qb64()).collect::<Vec<String>>(),
732                serder.said()
733            )));
734        }
735
736        // Check if fully signed vs prior next rotation threshold for rotations
737        if matches!(serder.ilk(), Some(Ilk::Rot) | Some(Ilk::Drt)) {
738            let ondices = self.exposeds(&sigers)?;
739            if let Some(ntholder) = self.ntholder.clone() {
740                if !ntholder.satisfy(&ondices) {
741                    // Escrow partially signed event
742                    self.escrow_ps_event(
743                        &serder,
744                        sigers.clone(),
745                        wigers,
746                        delseqner.as_ref(),
747                        delsaider.as_ref(),
748                        local,
749                    )?;
750
751                    return Err(KERIError::MissingSignatureError(format!(
752                        "AID {}...{}: Failure satisfying prior nsith = {:?} with exposed sigs {:?} for new est evt={:?}",
753                        &pre[..4],
754                        &pre[pre.len()-4..],
755                        ntholder.sith(),
756                        sigers.iter().map(|s| s.qb64()).collect::<Vec<String>>(),
757                        serder.said()
758                    )));
759                }
760            }
761        }
762
763        // Verify witness threshold (toad)
764        if wits.is_empty() {
765            if toader.num() != 0u128 {
766                return Err(KERIError::ValidationError(format!(
767                    "Invalid toad = {:?} for wits = {:?}",
768                    toader.num(),
769                    wits
770                )));
771            }
772        } else {
773            // Verify toad if not locally owned, membered, or witnessed
774            if !(self.locally_owned(locals, None)
775                || self.locally_membered(locals, None)
776                || self.locally_witnessed(locals, Some(&wits), None))
777            {
778                if !wits.is_empty() {
779                    if toader.num() < 1 || toader.num() as usize > wits.len() {
780                        return Err(KERIError::ValidationError(format!(
781                            "Invalid toad = {:?} for wits = {:?}",
782                            toader.num(),
783                            wits
784                        )));
785                    }
786                } else if toader.num() != 0 {
787                    return Err(KERIError::ValidationError(format!(
788                        "Invalid toad = {:?} for wits = {:?}",
789                        toader.num(),
790                        wits
791                    )));
792                }
793
794                if windices.len() < toader.num() as usize {
795                    // Escrow partially witnessed event
796                    if self.escrow_pw_event(
797                        &serder,
798                        wigers.clone(),
799                        sigers,
800                        delseqner.as_ref(),
801                        delsaider.as_ref(),
802                        local,
803                    )? {
804                        // TODO: Push cue to query for witness receipts if needed
805                    }
806
807                    return Err(KERIError::MissingWitnessSignatureError(format!(
808                        "AID {}...{}: Failure satisfying toad={:?} on witness sigs {:?} for event={:?}",
809                        &pre[..4],
810                        &pre[pre.len()-4..],
811                        toader.num(),
812                        wigers.map_or(vec![], |w| w.iter().map(|s| s.qb64()).collect::<Vec<String>>()),
813                        serder.said()
814                    )));
815                }
816            }
817        }
818
819        // Check delegation approval
820        if self.locally_delegated(locals, delpre.as_deref()) && !self.locally_owned(locals, None) {
821            if delseqner.is_none() || delsaider.is_none() {
822                // Escrow delegable event
823                self.escrow_delegable_event(&serder, &sigers, wigers, local)?;
824
825                return Err(KERIError::MissingDelegableApprovalError(format!(
826                    "Missing approval for delegation by {:?} of event = {:?}",
827                    delpre,
828                    serder.said()
829                )));
830            }
831        }
832
833        // Validate delegation if applicable
834        let (delseqner, delsaider) = self.validate_delegation(
835            locals,
836            &serder,
837            &sigers,
838            wigers.clone(),
839            &wits,
840            delpre.as_deref(),
841            delseqner.as_ref(),
842            delsaider.as_ref(),
843            eager,
844            local,
845        )?;
846
847        Ok((sigers, wigers, delpre, delseqner, delsaider))
848    }
849
850    fn locally_owned(&self, locals: &Locals, pre: Option<&str>) -> bool {
851        match pre {
852            Some(pre) => locals.prefixes.contains(pre) && !locals.groups.contains(pre),
853            None => match self.prefixer() {
854                Some(prefixer) => {
855                    locals.prefixes.contains(&prefixer.qb64())
856                        && !locals.groups.contains(&prefixer.qb64())
857                }
858                None => false,
859            },
860        }
861    }
862
863    fn locally_delegated(&self, locals: &Locals, delpre: Option<&str>) -> bool {
864        match delpre {
865            Some(delpre) => self.locally_owned(locals, Some(delpre)),
866            None => false,
867        }
868    }
869
870    fn locally_membered(&self, locals: &Locals, pre: Option<&str>) -> bool {
871        match pre {
872            Some(_) => locals.groups.contains(pre.unwrap()),
873            None => match self.prefixer() {
874                Some(prefixer) => locals.groups.contains(&prefixer.qb64()),
875                None => false,
876            },
877        }
878    }
879
880    /// Indices into `verfers` (a local group's current signing keys) of the
881    /// key contributed by the local member (keripy `locallyContributedIndices`).
882    /// Signatures at those indices may only come from a local source.
883    fn locally_contributed_indices(&self, verfers: &[Verfer]) -> Option<Vec<u32>> {
884        let pre = self.prefixer()?.qb64();
885        let habord = self.db.habs.get(&[pre.as_bytes()]).ok()??;
886        let mid = habord.mid?;
887        let state = self.db.states.get(&[mid.as_bytes()]).ok()??;
888        let mkey = state.k.first()?;
889        let idx = verfers.iter().position(|v| &v.qb64() == mkey)?;
890        Some(vec![idx as u32])
891    }
892
893    /// Returns true if a local controller is a witness of this Kever's KEL or the provided witness list
894    ///
895    /// # Arguments
896    /// * `wits` - Optional list of qb64 witness prefixes. If None, uses the current witnesses for this Kever
897    /// * `serder` - Optional SerderKERI instance. If provided, derives witnesses from it instead of current state
898    ///
899    /// # Returns
900    /// `true` if any of the prefixes in self.prefixes is also in the witness list; `false` otherwise
901    pub fn locally_witnessed(&self, locals: &Locals, wits: Option<&[String]>, serder: Option<&SerderKERI>) -> bool {
902        // Determine which witness list to use
903        let witnesses = match (wits, serder) {
904            // If both wits and serder are None, use this Kever's witnesses
905            (None, None) => self.wits(),
906
907            // If wits is provided, use it directly
908            (Some(w), _) => w.to_vec(),
909
910            // If serder is provided but no wits, derive witnesses from serder
911            (None, Some(s)) => {
912                // Check if serder is for the same KEL as this Kever
913                let prefixer = match self.prefixer() {
914                    Some(p) => p,
915                    None => return false, // No prefixer available
916                };
917
918                if s.pre() != Some(prefixer.qb64()) {
919                    return false; // Not the same KEL as self
920                }
921
922                // In Rust implementation, we need to call a method to derive witnesses from the serder
923                match self.derive_backs(s) {
924                    Ok((derived_wits, _, _)) => derived_wits,
925                    Err(_) => return false, // Error deriving witnesses, return false
926                }
927            }
928        };
929
930        // Check if any local prefixes are in the witness list
931        let local_prefix_set: HashSet<_> = locals.prefixes.iter().collect();
932        let witness_set: HashSet<_> = witnesses.iter().collect();
933
934        // Return true if the intersection is not empty
935        !local_prefix_set.is_disjoint(&witness_set)
936    }
937
938    /// Derives and returns tuple of (wits, cuts, adds) for backers given current set
939    /// and any changes provided by serder.
940    ///
941    /// # Arguments
942    /// * `serder` - Instance of current event
943    ///
944    /// # Returns
945    /// A tuple containing:
946    /// * `wits` - List of witness prefixes (full list of backers)
947    /// * `cuts` - List of witnesses removed in latest establishment event
948    /// * `adds` - List of witnesses added in latest establishment event
949    ///
950    /// # Errors
951    /// Returns ValidationError if there are invalid combinations of witnesses, cuts, or adds
952    pub fn derive_backs(
953        &self,
954        serder: &SerderKERI,
955    ) -> Result<(Vec<String>, Vec<String>, Vec<String>), KERIError> {
956        // Get current ilk from serder
957        let ilk = serder.ilk().unwrap();
958        let sn = serder.sn().unwrap();
959
960        // If not a rotation or delegation rotation event, or sequence number is not greater,
961        // return current values with no changes (keripy: core/eventing.py Kever.deriveBacks)
962        if (ilk != Ilk::Rot && ilk != Ilk::Drt)
963            || self.sner.as_ref().map_or(0, |n| n.num()) >= sn as u128
964        {
965            // Return current values with empty cuts and adds lists
966            return Ok((
967                self.wits(),
968                self.cuts.as_ref().map_or_else(Vec::new, |c| c.clone()),
969                self.adds.as_ref().map_or_else(Vec::new, |a| a.clone()),
970            ));
971        }
972
973        // Get the current witnesses and convert to HashSet for set operations
974        let wits = self.wits();
975        let wit_set: HashSet<String> = HashSet::from_iter(wits.iter().cloned());
976
977        // Extract cuts from serder
978        let cuts = serder.cuts().unwrap_or_else(|| Vec::new());
979
980        // Validate cuts: check for duplicates
981        let cut_set: HashSet<String> = HashSet::from_iter(cuts.iter().cloned());
982        if cut_set.len() != cuts.len() {
983            return Err(KERIError::ValidationError(format!(
984                "Invalid cuts = {:?}, has duplicates for evt = {:?}",
985                cuts,
986                serder.ked()
987            )));
988        }
989
990        // Validate that all cuts are in current witness set
991        if !cut_set.is_subset(&wit_set) {
992            return Err(KERIError::ValidationError(format!(
993                "Invalid cuts = {:?}, not all members in wits for evt = {:?}",
994                cuts,
995                serder.ked()
996            )));
997        }
998
999        // Extract adds from serder
1000        let adds = serder.adds().unwrap_or_else(|| Vec::new());
1001
1002        // Validate adds: check for duplicates
1003        let add_set: HashSet<String> = HashSet::from_iter(adds.iter().cloned());
1004        if add_set.len() != adds.len() {
1005            return Err(KERIError::ValidationError(format!(
1006                "Invalid adds = {:?}, has duplicates for evt = {:?}",
1007                adds,
1008                serder.ked()
1009            )));
1010        }
1011
1012        // Check that cuts and adds don't intersect
1013        if !cut_set.is_disjoint(&add_set) {
1014            return Err(KERIError::ValidationError(format!(
1015                "Intersecting cuts = {:?} and adds = {:?} for evt = {:?}",
1016                cuts,
1017                adds,
1018                serder.ked()
1019            )));
1020        }
1021
1022        // Check that current witnesses and adds don't intersect
1023        if !wit_set.is_disjoint(&add_set) {
1024            return Err(KERIError::ValidationError(format!(
1025                "Intersecting wits = {:?} and adds = {:?} for evt = {:?}",
1026                wits,
1027                adds,
1028                serder.ked()
1029            )));
1030        }
1031
1032        // Calculate new witness list: remove cuts, add adds
1033        // First remove cuts from wit_set
1034        let wit_set_after_cuts: HashSet<String> = wit_set.difference(&cut_set).cloned().collect();
1035
1036        // Then add adds to the set after cuts
1037        let new_wit_set: HashSet<String> = wit_set_after_cuts.union(&add_set).cloned().collect();
1038
1039        // Convert back to a vector
1040        let new_wits = new_wit_set.into_iter().collect::<Vec<String>>();
1041
1042        // Validate that the final witness count is correct
1043        if new_wits.len() != (wits.len() - cuts.len() + adds.len()) {
1044            return Err(KERIError::ValidationError(format!(
1045                "Invalid member combination among wits = {:?}, cuts = {:?}, and adds = {:?} for evt = {:?}",
1046                wits, cuts, adds, serder.ked()
1047            )));
1048        }
1049
1050        Ok((new_wits, cuts, adds))
1051    }
1052
1053    pub fn verfers(&self) -> Option<Vec<Verfer>> {
1054        self.verfers.clone()
1055    }
1056
1057    pub fn sner(&self) -> Option<Number> {
1058        self.sner.clone()
1059    }
1060
1061    pub fn last_est(&self) -> Option<LastEstLoc> {
1062        self.last_est.clone()
1063    }
1064
1065    /// Escrow an event from a remote source for an identifier that is locally
1066    /// owned, witnessed or delegated (keripy: core/eventing.py
1067    /// Kever.escrowMFEvent). Such an event is not processed further: only the
1068    /// local owner may decide on it, e.g. a delegator approving it.
1069    fn escrow_mf_event(
1070        &self,
1071        serder: &SerderKERI,
1072        sigers: Vec<Siger>,
1073        wigers: Option<Vec<Siger>>,
1074        _seqner: Option<&Seqner>,
1075        _saider: Option<&Saider>,
1076        local: bool,
1077    ) -> Result<(), KERIError> {
1078        self.escrow_event(serder, &sigers, wigers.as_deref(), local, &self.db.misfits)?;
1079        tracing::debug!("Kever: escrowed misfit event {}", serder.said().unwrap_or_default());
1080        Ok(())
1081    }
1082
1083    /// Escrow a partially signed event (keripy `escrowPSEvent`): store the
1084    /// event, its signatures, a first-escrowed timestamp and its source, and
1085    /// index it in `.pses` by prefix and sn. Signatures from later copies of
1086    /// the same event accumulate in `.sigs` until
1087    /// [`Kevery::process_escrow_partial_sigs`](super::kevery::Kevery) finds
1088    /// enough of them.
1089    ///
1090    /// Delegation seals (`.udes`) are not stored yet.
1091    fn escrow_ps_event(
1092        &self,
1093        serder: &SerderKERI,
1094        sigers: Vec<Siger>,
1095        wigers: Option<Vec<Siger>>,
1096        _seqner: Option<&Seqner>,
1097        _saider: Option<&Saider>,
1098        local: bool,
1099    ) -> Result<(), KERIError> {
1100        self.escrow_event(serder, &sigers, wigers.as_deref(), local, &self.db.pses)?;
1101        tracing::debug!("Kever: escrowed partially signed event {}", serder.said().unwrap_or_default());
1102        Ok(())
1103    }
1104
1105    /// Escrow a fully signed event that is short of witness signatures (keripy
1106    /// `escrowPWEvent`). Returns true when newly added to the escrow index.
1107    fn escrow_pw_event(
1108        &self,
1109        serder: &SerderKERI,
1110        wigers: Option<Vec<Siger>>,
1111        sigers: Vec<Siger>,
1112        _seqner: Option<&Seqner>,
1113        _saider: Option<&Saider>,
1114        local: bool,
1115    ) -> Result<bool, KERIError> {
1116        let added = self.escrow_event(serder, &sigers, wigers.as_deref(), local, &self.db.pwes)?;
1117        tracing::debug!("Kever: escrowed partially witnessed event {}", serder.said().unwrap_or_default());
1118        Ok(added)
1119    }
1120
1121    fn escrow_event(
1122        &self,
1123        serder: &SerderKERI,
1124        sigers: &[Siger],
1125        wigers: Option<&[Siger]>,
1126        local: bool,
1127        index: &crate::keri::db::subing::iodup::IoDupSuber,
1128    ) -> Result<bool, KERIError> {
1129        escrow_event(&self.db, serder, sigers, wigers, local, index)
1130    }
1131}
1132
1133/// Store an event with its signatures, first-escrow time and source, and
1134/// index it by snKey(pre, sn) -> said in `index`. Delegation seals are not
1135/// stored yet. Returns true when `index` did not already hold the event.
1136///
1137/// Shared by the Kever escrows and the Kevery ones that run before a Kever
1138/// exists (out of order).
1139pub(crate) fn escrow_event(
1140    db: &Baser,
1141    serder: &SerderKERI,
1142    sigers: &[Siger],
1143    wigers: Option<&[Siger]>,
1144    local: bool,
1145    index: &crate::keri::db::subing::iodup::IoDupSuber,
1146) -> Result<bool, KERIError> {
1147    {
1148        let pre = serder
1149            .pre()
1150            .ok_or_else(|| KERIError::ValueError("escrow: event has no prefix".to_string()))?;
1151        let said = serder
1152            .said()
1153            .ok_or_else(|| KERIError::ValueError("escrow: event has no said".to_string()))?
1154            .to_string();
1155        let sn = serder
1156            .sn()
1157            .ok_or_else(|| KERIError::ValueError("escrow: event has no sn".to_string()))?;
1158        let dg_keys = [pre.as_str(), said.as_str()];
1159
1160        // Idempotent: the first escrow time is kept, so the timeout runs from it.
1161        let existing: Vec<Vec<u8>> = db.dtss.get(&dg_keys)?;
1162        if existing.is_empty() {
1163            let now = chrono::Utc::now().to_rfc3339().into_bytes();
1164            db.dtss.add(&dg_keys, &now)?;
1165        }
1166        for siger in sigers {
1167            db.sigs.add(&dg_keys, &siger.qb64().into_bytes().as_slice())?;
1168        }
1169        for wiger in wigers.into_iter().flatten() {
1170            db.wigs.add(&dg_keys, &wiger.qb64().into_bytes().as_slice())?;
1171        }
1172        db.evts.put(&dg_keys, &serder.raw())?;
1173
1174        match db.esrs.get(&dg_keys) {
1175            Ok(Some(mut esr)) => {
1176                if local && !esr.local {
1177                    // A local copy upgrades a previously remote source.
1178                    esr.local = true;
1179                    db.esrs.pin(&dg_keys, &esr)?;
1180                }
1181            }
1182            _ => {
1183                db.esrs.put(&dg_keys, &EventSourceRecord::with_local(local))?;
1184            }
1185        }
1186
1187        Ok(index.add(&[sn_key(&pre, sn)], &said.into_bytes())?)
1188    }
1189}
1190
1191impl Kever {
1192    /// Escrow a delegated event, for a locally owned delegator, that has no
1193    /// approval yet (keripy: core/eventing.py Kever.escrowDelegableEvent).
1194    /// The delegator approves it with `Habery::approve_delegation`.
1195    fn escrow_delegable_event(
1196        &self,
1197        serder: &SerderKERI,
1198        sigers: &[Siger],
1199        wigers: Option<Vec<Siger>>,
1200        local: bool,
1201    ) -> Result<(), KERIError> {
1202        self.escrow_event(serder, sigers, wigers.as_deref(), local, &self.db.delegables)?;
1203        tracing::debug!("Kever: escrowed delegable event {}", serder.said().unwrap_or_default());
1204        Ok(())
1205    }
1206
1207    /// Returns a list of indices (ondices) suitable for Tholder.satisfy
1208    /// from self.ndigers (prior next key digests) as exposed by event sigers.
1209    /// Uses dual index feature of siger. Assumes that each siger.verfer is
1210    /// from the correct key given by siger.index and the signature has been verified.
1211    ///
1212    /// A key given by siger.verfer (at siger.index in the current key list)
1213    /// may expose a prior next key hidden by the diger at siger.ondex in .digers.
1214    ///
1215    /// Each returned ondex must be properly exposed by a siger in sigers
1216    /// such that the siger's indexed key given by siger.verfer matches the
1217    /// siger's ondexed digest from digers.
1218    ///
1219    /// The ondexed digest's code is used to compute the digest of the corresponding
1220    /// indexed key verfer to verify that they match. This supports crypto agility
1221    /// for different digest codes, i.e., all digests in .digers may use a different
1222    /// algorithm.
1223    ///
1224    /// Only ondices from properly matching key and digest are returned.
1225    ///
1226    /// # Arguments
1227    ///
1228    /// * `sigers` - Vector of Siger instances of indexed signatures with .verfer
1229    ///
1230    /// # Returns
1231    ///
1232    /// * `Result<Vec<usize>, KERIError>` - Vector of ondices that are properly exposed
1233    fn exposeds(&self, sigers: &[Siger]) -> Result<Vec<usize>, KERIError> {
1234        let mut odxs = Vec::new();
1235
1236        // Get ndigers or return empty vector if not available
1237        let ndigers = match &self.ndigers {
1238            Some(digers) => digers,
1239            None => return Ok(odxs),
1240        };
1241
1242        for siger in sigers {
1243            let ondex = match siger.ondex() {
1244                Some(ondex) => ondex as usize,
1245                None => continue,
1246            };
1247
1248            if ondex >= ndigers.len() {
1249                continue;
1250            }
1251            let diger = &ndigers[ondex];
1252
1253            let verfer = match siger.verfer() {
1254                Some(vrf) => vrf,
1255                None => continue,
1256            };
1257
1258            // Digest the verfer's qb64b (not raw) to match how digers are
1259            // created during key generation — mirrors keripy's exposeds
1260            let kdig = match Diger::from_ser(&mut verfer.qb64b(), Some(diger.code())) {
1261                Ok(d) => d.qb64(),
1262                Err(_) => continue,
1263            };
1264
1265            if kdig == diger.qb64() {
1266                odxs.push(ondex);
1267            }
1268        }
1269
1270        Ok(odxs)
1271    }
1272
1273    /// Validate the delegation of a delegated event (keripy: core/eventing.py
1274    /// Kever.validateDelegation).
1275    ///
1276    /// - The delegate's controller, a group member of the delegate and the
1277    ///   delegate's witnesses accept the event before approval, so that they
1278    ///   can go on to collect receipts and approval; no seal is recorded.
1279    /// - Anyone else needs the delegating event: the attached source seal
1280    ///   couple (`delseqner`, `delsaider`) or, when `eager`, the last fully
1281    ///   witnessed event of the delegator's KEL that anchors the seal. The
1282    ///   delegating event must be the delegator's last (not superseded) event
1283    ///   at that sn and must anchor `{i, s, d}` of this event.
1284    ///
1285    /// Not ported yet: the partial-delegation escrow (keripy `escrowPDEvent`),
1286    /// so an event without its delegating event is dropped with
1287    /// `MissingDelegationError`, and the superseding rules for recovery
1288    /// rotations (see DIVERGENCES.md).
1289    fn validate_delegation(
1290        &self,
1291        locals: &Locals,
1292        serder: &SerderKERI,
1293        _sigers: &[Siger],
1294        _wigers: Option<Vec<Siger>>,
1295        wits: &[String],
1296        delpre: Option<&str>,
1297        delseqner: Option<&Seqner>,
1298        delsaider: Option<&Saider>,
1299        eager: bool,
1300        _local: bool,
1301    ) -> Result<(Option<Seqner>, Option<Saider>), KERIError> {
1302        let Some(delpre) = delpre else {
1303            return Ok((None, None)); // not delegated
1304        };
1305
1306        if self.locally_owned(locals, None)
1307            || self.locally_membered(locals, None)
1308            || self.locally_witnessed(locals, Some(wits), None)
1309        {
1310            return Ok((None, None)); // accepted before approval, so no seal
1311        }
1312
1313        let pre = serder
1314            .pre()
1315            .ok_or_else(|| KERIError::ValueError("delegated event has no prefix".to_string()))?;
1316        let sn = serder
1317            .sn()
1318            .ok_or_else(|| KERIError::ValueError("delegated event has no sn".to_string()))?;
1319        let said = serder
1320            .said()
1321            .ok_or_else(|| KERIError::ValueError("delegated event has no SAID".to_string()))?
1322            .to_string();
1323        let what = format!("evt {} {:?} {}", sn, serder.ilk(), said);
1324
1325        // The delegator's key state (keripy `self.kevers[delpre]`).
1326        let Some(dstate) = self.db.states.get(&[delpre.as_bytes()]).ok().flatten() else {
1327            return Err(KERIError::MissingDelegationError(format!(
1328                "Missing KEL of delegator {} of {}",
1329                delpre, what
1330            )));
1331        };
1332        if dstate.c.iter().any(|t| t == "DND") {
1333            return Err(KERIError::ValidationError(format!(
1334                "Delegator {} does not allow delegation on {}",
1335                delpre, what
1336            )));
1337        }
1338
1339        let seal = crate::keri::core::eventing::SealEvent::new(pre.clone(), format!("{:x}", sn), said.clone());
1340        let (dsn, dsaid) = match (delseqner, delsaider) {
1341            (Some(seqner), Some(saider)) => (seqner.sn(), saider.qb64()),
1342            _ if eager => {
1343                let toad = u64::from_str_radix(&dstate.bt, 16).unwrap_or(0) as usize;
1344                match self.db.fetch_last_sealing_event_by_event_seal(delpre, &seal, 0, toad)? {
1345                    Some(dserder) => (
1346                        dserder.sn().unwrap_or_default(),
1347                        dserder.said().unwrap_or_default().to_string(),
1348                    ),
1349                    None => {
1350                        return Err(KERIError::MissingDelegationError(format!(
1351                            "No delegation seal for delegator {} on {}",
1352                            delpre, what
1353                        )))
1354                    }
1355                }
1356            }
1357            _ => {
1358                return Err(KERIError::MissingDelegationError(format!(
1359                    "No delegation seal for delegator {} on {}",
1360                    delpre, what
1361                )))
1362            }
1363        };
1364
1365        // The delegating event must be the delegator's last event at dsn and
1366        // must anchor this event's seal.
1367        let Some(last) = self.db.get_ke_last(sn_key(delpre, dsn))? else {
1368            return Err(KERIError::MissingDelegationError(format!(
1369                "No delegating event from {} at sn {} for {}",
1370                delpre, dsn, what
1371            )));
1372        };
1373        if last != dsaid {
1374            return Err(KERIError::ValidationError(format!(
1375                "Delegating event {} of {} at sn {} is not its last event {} for {}",
1376                dsaid, delpre, dsn, last, what
1377            )));
1378        }
1379        let raw = self.db.get_evt(dg_key(delpre, &dsaid))?.ok_or_else(|| {
1380            KERIError::ValidationError(format!("Missing delegating event {} for {}", dsaid, what))
1381        })?;
1382        let dserder = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(&raw, None)?;
1383        let anchored = dserder.seals().unwrap_or_default().iter().any(|eseal| {
1384            eseal.get("i").and_then(|v| v.as_str()) == Some(seal.i.as_str())
1385                && eseal.get("s").and_then(|v| v.as_str()) == Some(seal.s.as_str())
1386                && eseal.get("d").and_then(|v| v.as_str()) == Some(seal.d.as_str())
1387        });
1388        if !anchored {
1389            return Err(KERIError::ValidationError(format!(
1390                "Delegating event {} of {} does not anchor {}",
1391                dsaid, delpre, what
1392            )));
1393        }
1394        Ok((
1395            Some(Seqner::from_sn(dsn as u128)),
1396            Some(Saider::from_qb64(&dsaid).map_err(|e| KERIError::ValueError(format!("saider: {}", e)))?),
1397        ))
1398    }
1399
1400    /// Not an inception event. Verify event serder and indexed signatures
1401    /// in sigers and update state
1402    ///
1403    /// # Arguments
1404    ///
1405    /// * `serder` - Instance of event
1406    /// * `sigers` - List of SigMat instances of indexed signatures of controller
1407    ///             signatures of event. Index is offset into keys list from latest
1408    ///             est event and when provided index is offset into key digest list
1409    ///             from prior next est event to latest est event.
1410    /// * `wigers` - Optional list of Siger instances of indexed witness signatures of
1411    ///             event. Index is offset into wits list from latest est event
1412    /// * `delseqner` - Optional instance of delegating event sequence number.
1413    ///                If this event is not delegated then seqner is ignored
1414    /// * `delsaider` - Optional instance of delegating event said.
1415    ///                If this event is not delegated then diger is ignored
1416    /// * `firner` - Optional Seqner instance of cloned first seen ordinal
1417    ///             If cloned mode then firner maybe provided (not None)
1418    ///             When firner provided then compare fn of dater and database and
1419    ///             first seen if not match then log and add cue notify problem
1420    /// * `dater` - Optional Dater instance of cloned replay datetime
1421    ///            If cloned mode then dater maybe provided (not None)
1422    ///            When dater provided then use dater for first seen datetime
1423    /// * `eager` - If true, try harder to find validate events by walking KELs.
1424    ///            Enables only being eager in escrow processing not initial parsing.
1425    ///            If false, only use pre-existing information if any.
1426    /// * `local` - Event source for validation logic.
1427    ///            True means event source is local (protected).
1428    ///            False means event source is remote (unprotected).
1429    /// * `check` - If true, do not update the database in any non-idempotent way.
1430    ///            Useful for reinitializing the Kevers from a persisted KEL without
1431    ///            updating non-idempotent first seen .fels and timestamps.
1432    ///
1433    /// # Returns
1434    ///
1435    /// * `Result<(), KERIError>` - Ok if successful, Error otherwise
1436    pub fn update(
1437        &mut self,
1438        locals: &Locals,
1439        serder: SerderKERI,
1440        sigers: Vec<Siger>,
1441        wigers: Option<Vec<Siger>>,
1442        delseqner: Option<Seqner>,
1443        delsaider: Option<Saider>,
1444        firner: Option<Seqner>,
1445        dater: Option<Dater>,
1446        eager: bool,
1447        local: bool,
1448        check: bool,
1449    ) -> Result<(), KERIError> {
1450        let ked = &serder.ked();
1451
1452        // Check if identifier is transferable
1453        if !self.transferable() {
1454            return Err(KERIError::ValidationError(
1455                "Can't rotate; Prefixer is either missing or identifier is non-transferrable"
1456                    .to_string(),
1457            ));
1458        }
1459
1460        // Check if event prefix matches kever prefixer
1461        if serder.pre() != Some(self.prefixer.clone().unwrap().qb64()) {
1462            return Err(KERIError::ValidationError(format!(
1463                "Mismatch event aid prefix = {} expecting = {} for evt = {:?}",
1464                serder.pre().unwrap(),
1465                self.prefixer.as_ref().unwrap().qb64(),
1466                ked
1467            )));
1468        }
1469
1470        let local = local; // No conversion needed, bool is already bool
1471
1472        let sner = serder.sn().unwrap_or_default(); // Get sequence number from serder
1473        let ilk = serder.ilk().unwrap();
1474
1475        // Handle rotation or delegated rotation event
1476        if ilk == Ilk::Rot || ilk == Ilk::Drt {
1477            // Check if trying to do non-delegated rotation on delegated prefix
1478            if self.delegated && ilk != Ilk::Drt {
1479                return Err(KERIError::ValidationError(format!(
1480                    "Attempted non delegated rotation on delegated pre = {} with evt = {:?}",
1481                    serder.pre().unwrap(),
1482                    ked
1483                )));
1484            }
1485
1486            // Validate rotation
1487            let (tholder, toader, wits, cuts, adds) = self.rotate(&serder)?;
1488
1489            // Validate signatures, delegation if any, and witnessing when applicable
1490            let (sigers_verified, wigers_verified, _, delseqner_updated, delsaider_updated) = self
1491                .val_sigs_wigs_del(locals,
1492                    serder.clone(),
1493                    sigers,
1494                    serder.verfers(),
1495                    tholder.clone(),
1496                    wigers,
1497                    Some(toader.clone()),
1498                    wits.clone(),
1499                    delseqner,
1500                    delsaider,
1501                    eager,
1502                    local,
1503                )?;
1504
1505            // Log event to KEL and FEL if not in check mode
1506            let (fn_val, dts) = self.log_event(locals,
1507                serder.clone(),
1508                sigers_verified,
1509                wigers_verified,
1510                Some(wits.clone()),
1511                !check, // first
1512                delseqner_updated,
1513                delsaider_updated,
1514                firner,
1515                dater,
1516                local,
1517            )?;
1518
1519            // Update state
1520            self.sner = Some(Number::from_num(&BigUint::from(sner))?);
1521            self.serder = Some(serder.clone());
1522            self.ilk = ilk; // Default to Rot if unknown
1523            self.tholder = Some(tholder);
1524            self.verfers = serder.verfers();
1525            self.ndigers = serder.ndigers();
1526            self.ntholder = serder.ntholder();
1527            self.toader = Some(toader);
1528            self.wits = Some(wits);
1529            self.cuts = Some(cuts);
1530            self.adds = Some(adds);
1531
1532            // Last establishment event location needed to recognize recovery events
1533            self.last_est = Some(LastEstLoc {
1534                s: sner,
1535                d: serder.said().unwrap().to_string(),
1536            });
1537
1538            // Update first seen number and date if not in check mode
1539            if let Some(fn_num) = fn_val {
1540                self.fner = Some(Number::from_num(&BigUint::from(fn_num))?);
1541                self.dater = Some(Dater::from_dt(dts));
1542                // Update state in database
1543                if let Some(prefixer) = &self.prefixer {
1544                    self.db.states.pin(&[&prefixer.qb64()], &self.state()?)?;
1545                }
1546            }
1547        }
1548        // Handle interaction event
1549        else if ilk == Ilk::Ixn {
1550            // Check if est_only is true
1551            if self.est_only.unwrap_or(false) {
1552                return Err(KERIError::ValidationError(format!(
1553                    "Unexpected non-establishment event = {:?}",
1554                    serder.ked()
1555                )));
1556            }
1557
1558            // Check sequence number
1559            let self_sn = self.sner.as_ref().map(|n| n.num()).unwrap_or(0);
1560            if sner != (self_sn + 1) as u64 {
1561                return Err(KERIError::ValidationError(format!(
1562                    "Invalid sn = {} expecting = {} for evt = {:?}",
1563                    sner,
1564                    self_sn + 1,
1565                    ked
1566                )));
1567            }
1568
1569            // Check prior event digest
1570            let self_said = self.serder.as_ref().map(|s| s.said()).unwrap_or_default();
1571            if ked["p"] != SadValue::String(self_said.unwrap_or_default().to_string()) {
1572                return Err(KERIError::ValidationError(format!(
1573                    "Mismatch event dig = {} with state dig = {} for evt = {:?}",
1574                    ked["p"].as_str().unwrap(),
1575                    self_said.unwrap(),
1576                    ked
1577                )));
1578            }
1579
1580            // Use keys, sith, toad, and wits from pre-existing Kever state
1581            let verfers = self.verfers.clone().ok_or_else(|| {
1582                KERIError::ValidationError("Missing verfers in Kever state".to_string())
1583            })?;
1584
1585            let tholder = self.tholder.clone().ok_or_else(|| {
1586                KERIError::ValidationError("Missing tholder in Kever state".to_string())
1587            })?;
1588
1589            let toader = self.toader.clone().ok_or_else(|| {
1590                KERIError::ValidationError("Missing toader in Kever state".to_string())
1591            })?;
1592
1593            let wits = self.wits.clone().unwrap_or_default();
1594
1595            // Validate signatures, delegation, and witnessing
1596            let (sigers_verified, wigers_verified, _, _, _) = self.val_sigs_wigs_del(locals,
1597                serder.clone(),
1598                sigers,
1599                Some(verfers),
1600                tholder,
1601                wigers,
1602                Some(toader),
1603                wits,
1604                None, // No delegation for ixn events
1605                None, // No delegation for ixn events
1606                eager,
1607                local,
1608            )?;
1609
1610            // Log event to KEL and FEL if not in check mode
1611            let (fn_val, dts) = self.log_event(locals,
1612                serder.clone(),
1613                sigers_verified,
1614                wigers_verified,
1615                None,   // No wits param for ixn
1616                !check, // first
1617                None,   // No delegation for ixn
1618                None,   // No delegation for ixn
1619                None,   // No firner for standard ixn
1620                None,   // No dater for standard ixn
1621                local,
1622            )?;
1623
1624            // Update state
1625            self.sner = Some(Number::from_num(&BigUint::from(sner))?);
1626            self.serder = Some(serder);
1627            self.ilk = ilk;
1628
1629            // Update first seen number and date if not in check mode
1630            if let Some(fn_num) = fn_val {
1631                self.fner = Some(Number::from_num(&BigUint::from(fn_num))?);
1632                self.dater = Some(Dater::from_dt(dts));
1633                // Update state in database
1634                if let Some(prefixer) = &self.prefixer {
1635                    self.db.states.pin(&[&prefixer.qb64()], &self.state()?)?;
1636                }
1637            }
1638        }
1639        // Handle unsupported event type
1640        else {
1641            return Err(KERIError::ValidationError(format!(
1642                "Unsupported ilk = {} for evt = {:?}",
1643                ilk, ked
1644            )));
1645        }
1646
1647        Ok(())
1648    }
1649
1650    /// Generic Rotate Operation Validation Processing
1651    /// Validates provisional rotation
1652    /// Same logic for both 'rot' and 'drt' (plain and delegated rotation)
1653    ///
1654    /// # Arguments
1655    ///
1656    /// * `serder` - Instance of rotation ('rot' or 'drt') event.
1657    ///
1658    /// # Returns
1659    ///
1660    /// A tuple (tholder, toader, wits, cuts, adds) of provisional results
1661    /// of rotation subject to additional validation
1662    ///
1663    /// # Errors
1664    ///
1665    /// * `ValidationError` - if the rotation event is invalid
1666    /// * `ValueError` - if the toad value is invalid
1667    pub fn rotate(
1668        &self,
1669        serder: &SerderKERI,
1670    ) -> Result<(Tholder, Number, Vec<String>, Vec<String>, Vec<String>), KERIError> {
1671        let ked = &serder.ked();
1672        let sn = serder.sn().unwrap_or_default();
1673        let pre = serder.pre().unwrap();
1674        let prior = serder.prior().unwrap();
1675        let ilk = serder.ilk().unwrap();
1676
1677        // Get current sequence number from self
1678        let self_sn = self.sner.as_ref().map(|n| n.num()).unwrap_or(0);
1679
1680        // Check if the event i3s out of order
1681        if sn > (self_sn + 1) as u64 {
1682            return Err(KERIError::ValidationError(format!(
1683                "Out of order event sn = {} expecting = {} for evt = {:?}",
1684                sn,
1685                self_sn + 1,
1686                ked
1687            )));
1688        } else if sn <= self_sn as u64 {
1689            // Event is stale or recovery
1690            let last_est_sn = self.last_est.as_ref().map(|l| l.s).unwrap_or(0);
1691
1692            if (ilk == Ilk::Rot && sn <= last_est_sn) || (ilk == Ilk::Drt && sn < last_est_sn) {
1693                // Stale event
1694                return Err(KERIError::ValidationError(format!(
1695                    "Stale event sn = {} expecting = {} for evt = {:?}",
1696                    sn,
1697                    self_sn + 1,
1698                    ked
1699                )));
1700            } else {
1701                // Recovery event
1702                if ilk == Ilk::Rot && self.ilk != Ilk::Ixn {
1703                    // Recovery may only override ixn state
1704                    return Err(KERIError::ValidationError(format!(
1705                        "Invalid recovery attempt: Recovery at ilk = {} not ilk = {} for evt = {:?}",
1706                        self.ilk, Ilk::Ixn, ked
1707                    )));
1708                }
1709
1710                // Use sn of prior event to fetch prior event
1711                let psn = sn - 1;
1712
1713                // Fetch raw serialization of last inserted event at psn
1714                let key = sn_key(pre.clone(), psn);
1715                let pdig = match self.db.kels.get_last(&[&key])? {
1716                    Some(dig) => match String::from_utf8(dig) {
1717                        Ok(d) => d,
1718                        Err(_) => return Err(KERIError::ValueError("Invalid digest".to_string())),
1719                    },
1720                    None => {
1721                        return Err(KERIError::ValidationError(format!(
1722                            "Invalid recovery attempt: Bad sn = {} for event = {:?}",
1723                            psn, ked
1724                        )))
1725                    }
1726                };
1727
1728                // Get the event from database
1729                let dig_key = dg_key(pre, pdig.clone());
1730                let praw = match self.db.evts.get::<_, Vec<u8>>(&[&dig_key])? {
1731                    Some(raw) => raw,
1732                    None => {
1733                        return Err(KERIError::ValidationError(format!(
1734                            "Invalid recovery attempt: Bad dig = {}",
1735                            pdig
1736                        )))
1737                    }
1738                };
1739
1740                // Deserialize prior event
1741                let pserder = SerderKERI::from_raw(&praw, None)
1742                    .map_err(|e| KERIError::ValueError(format!("Invalid prior event: {}", e)))?;
1743
1744                // Compare prior said with retrieved event said
1745                if prior != pserder.said().unwrap_or_default() {
1746                    return Err(KERIError::ValidationError(format!(
1747                        "Invalid recovery attempt: Mismatch recovery event prior dig = {} with dig = {:?} of event sn = {} evt = {:?}",
1748                        prior, pserder.said(), psn, ked
1749                    )));
1750                }
1751            }
1752        } else {
1753            // New non-recovery event (sn == self_sn + 1)
1754            // Check if prior event dig matches current event said
1755            let self_said = self.serder.as_ref().map(|s| s.said()).unwrap_or_default();
1756            if prior != self_said.unwrap_or_default() {
1757                return Err(KERIError::ValidationError(format!(
1758                    "Mismatch event dig = {} with state dig = {:?} for evt = {:?}",
1759                    prior, self_said, ked
1760                )));
1761            }
1762        }
1763
1764        // Check if rotation is allowed (non-transferable check)
1765        if self.ndigers.is_none() || self.ndigers.as_ref().map_or(true, |d| d.is_empty()) {
1766            return Err(KERIError::ValidationError(format!(
1767                "Attempted rotation for nontransferable prefix = {} for evt = {:?}",
1768                self.prefixer.as_ref().map(|p| p.qb64()).unwrap_or_default(),
1769                ked
1770            )));
1771        }
1772
1773        // Parse threshold and keys
1774        let tholder = serder.tholder().unwrap_or_default();
1775        let keys = serder.keys().unwrap_or_default();
1776
1777        // Check if keys are sufficient for threshold
1778        if keys.len() < tholder.size() {
1779            return Err(KERIError::ValidationError(format!(
1780                "Invalid sith = {} for keys = {:?} for evt = {:?}",
1781                tholder.sith(),
1782                keys,
1783                ked
1784            )));
1785        }
1786
1787        // Compute witnesses from existing wits with new cuts and adds from event
1788        let (wits, cuts, adds) = self.derive_backs(serder)?;
1789
1790        // Get witness threshold from event
1791        let toader = serder.bner().unwrap_or_default();
1792
1793        // Validate witness threshold
1794        if !wits.is_empty() {
1795            if toader.num() < 1 || toader.num() > wits.len() as u128 {
1796                return Err(KERIError::ValueError(format!(
1797                    "Invalid toad = {} for backers (wits)={:?} for event={:?}",
1798                    toader.num(),
1799                    wits,
1800                    ked
1801                )));
1802            }
1803        } else {
1804            if toader.num() != 0 {
1805                return Err(KERIError::ValueError(format!(
1806                    "Invalid toad = {} for backers (wits)={:?} for event={:?}",
1807                    toader.num(),
1808                    wits,
1809                    ked
1810                )));
1811            }
1812        }
1813
1814        Ok((tholder, toader, wits, cuts, adds))
1815    }
1816
1817    pub fn log_event(
1818        &self,
1819        locals: &Locals,
1820        serder: SerderKERI,
1821        sigers: Vec<Siger>,
1822        wigers: Option<Vec<Siger>>,
1823        wits: Option<Vec<String>>,
1824        first: bool,
1825        seqner: Option<Seqner>,
1826        saider: Option<Saider>,
1827        _firner: Option<Seqner>,
1828        dater: Option<Dater>,
1829        local: bool,
1830    ) -> Result<(Option<u64>, chrono::DateTime<chrono::Utc>), KERIError> {
1831        // Default values
1832        let local = if local { true } else { false };
1833        let mut fn_num: Option<u64> = None; // None means not a first seen log event
1834
1835        // Create digest key for the event
1836        let dg_keys = vec![serder.pre().unwrap(), serder.said().unwrap().to_string()]; // For esrs database
1837
1838        // Get current timestamp in ISO 8601 format
1839        let now = chrono::Utc::now();
1840        let dts_b = now.to_rfc3339().into_bytes();
1841
1842        // Put datetime stamp (idempotent, won't change if already exists)
1843        self.db.dtss.add(&dg_keys, &dts_b)?;
1844
1845        // Store signatures if provided
1846        if !sigers.is_empty() {
1847            for siger in sigers.iter() {
1848                self.db
1849                    .sigs
1850                    .add(&dg_keys, &siger.qb64().into_bytes().as_slice())?;
1851            }
1852        }
1853
1854        // Store witness signatures if provided
1855        if let Some(wigers) = &wigers {
1856            for wiger in wigers.iter() {
1857                self.db
1858                    .wigs
1859                    .add(&dg_keys, &wiger.qb64().into_bytes().as_slice())?;
1860            }
1861        }
1862
1863        // Store witnesses if provided
1864        if let Some(wits) = &wits {
1865            if !wits.is_empty() {
1866                for wit in wits {
1867                    self.db
1868                        .wits
1869                        .add(&dg_keys, &wit.clone().into_bytes().as_slice())?;
1870                }
1871            }
1872        }
1873
1874        // Store serialized event (idempotent, may already be escrowed)
1875        self.db.evts.put(&dg_keys, &serder.raw())?;
1876
1877        // Handle delegation for authorized delegated or issued event
1878        if self.delpre.is_some()
1879            && serder.ilk() != Some(Ilk::Ixn)
1880            && !self.locally_owned(locals, None)
1881            && !self.locally_witnessed(locals, Some(wits.as_deref().unwrap_or(&[])), None)
1882            && seqner.is_some()
1883            && saider.is_some()
1884        {
1885            // Create authorizer (delegator/issuer) event seal couple
1886            let seqner = seqner.unwrap();
1887            let saider = saider.unwrap();
1888            let couple = [seqner.qb64().as_bytes(), saider.qb64().as_bytes()].concat();
1889            self.db.aess.put(&dg_keys, &couple)?;
1890        }
1891
1892        // Update event source record
1893        let _esr = match self.db.esrs.get(&dg_keys) {
1894            Ok(Some(mut esr)) => {
1895                // If local and existing record is remote, update to local
1896                if local && !esr.local {
1897                    esr.local = local;
1898                    self.db.esrs.pin(&dg_keys, &esr)?;
1899                }
1900                esr
1901            }
1902            _ => {
1903                // Not preexisting, create and store new record
1904                let esr = EventSourceRecord::with_local(local);
1905                self.db.esrs.put(&dg_keys, &esr)?;
1906                esr
1907            }
1908        };
1909
1910        // Handle first seen events
1911        if first {
1912            // Append event digest to first seen database in order
1913            match self
1914                .db
1915                .fels
1916                .append_on(&[&serder.preb().unwrap()], &serder.saidb().unwrap())
1917            {
1918                Ok(fn_val) => {
1919                    fn_num = Some(fn_val);
1920
1921                    // Use original timestamp from dater for cloned replay
1922                    let dts_to_set = match &dater {
1923                        Some(d) => d.dtsb(),
1924                        None => dts_b.clone(),
1925                    };
1926
1927                    // Set first seen timestamp
1928                    self.db.dtss.pin(&dg_keys, &[&dts_to_set])?;
1929
1930                    // Store first seen ordinal number
1931                    let fn_seqner = Number::from_num(&BigUint::from(fn_val))?;
1932                    self.db.fons.pin(&dg_keys, &fn_seqner)?;
1933                }
1934                Err(e) => {
1935                    return Err(KERIError::DatabaseError(format!(
1936                        "Failed to append to FEL: {}",
1937                        e
1938                    )))
1939                }
1940            }
1941        }
1942
1943        // Add event to Key Event Log
1944        let sn_key = sn_key(serder.preb().unwrap(), serder.sn().unwrap());
1945        self.db.kels.add(&[sn_key], &serder.saidb().unwrap())?;
1946
1947        // Return first seen number (if any) and timestamp
1948        Ok((fn_num, now))
1949    }
1950
1951    /// Returns KeyStateRecord instance of current key state
1952    pub fn state(&self) -> Result<KeyStateRecord, KERIError> {
1953        // Ensure required fields are available
1954        let prefixer = self
1955            .prefixer()
1956            .ok_or_else(|| KERIError::ValueError("Missing prefixer in Kever state".to_string()))?;
1957
1958        let tholder = self
1959            .tholder()
1960            .ok_or_else(|| KERIError::ValueError("Missing tholder in Kever state".to_string()))?;
1961
1962        let serder = self
1963            .serder
1964            .as_ref()
1965            .ok_or_else(|| KERIError::ValueError("Missing serder in Kever state".to_string()))?;
1966
1967        let sner = self
1968            .sner
1969            .as_ref()
1970            .ok_or_else(|| KERIError::ValueError("Missing sner in Kever state".to_string()))?;
1971
1972        let fner = self
1973            .fner
1974            .as_ref()
1975            .ok_or_else(|| KERIError::ValueError("Missing fner in Kever state".to_string()))?;
1976
1977        let dater = self
1978            .dater
1979            .as_ref()
1980            .ok_or_else(|| KERIError::ValueError("Missing dater in Kever state".to_string()))?;
1981
1982        let verfers = self
1983            .verfers
1984            .as_ref()
1985            .ok_or_else(|| KERIError::ValueError("Missing verfers in Kever state".to_string()))?;
1986
1987        let toader = self
1988            .toader()
1989            .ok_or_else(|| KERIError::ValueError("Missing toader in Kever state".to_string()))?;
1990
1991        let last_est = self
1992            .last_est
1993            .as_ref()
1994            .ok_or_else(|| KERIError::ValueError("Missing last_est in Kever state".to_string()))?;
1995
1996        // Create StateEstEvent
1997        let eevt = StateEERecord {
1998            s: format!("{:x}", last_est.s),
1999            d: last_est.d.clone(),
2000            br: self.cuts.clone(),
2001            ba: self.adds.clone(),
2002        };
2003
2004        // Create configuration traits
2005        let mut cnfg = Vec::new();
2006        if self.est_only.unwrap_or(false) {
2007            cnfg.push(trait_dex::EST_ONLY.to_string());
2008        }
2009        if self.do_not_delegate.unwrap_or(false) {
2010            cnfg.push(trait_dex::DO_NOT_DELEGATE.to_string());
2011        }
2012
2013        // Collect signing keys
2014        let keys: Vec<String> = verfers.iter().map(|verfer| verfer.qb64()).collect();
2015
2016        // Get next key digests
2017        let ndigs = match &self.ndigers {
2018            Some(digers) => digers.iter().map(|diger| diger.qb64()).collect(),
2019            None => Vec::new(),
2020        };
2021
2022        // Get witnesses
2023        let wits = self.wits().clone();
2024
2025        // Get prior event digest and handle None case
2026        let pig = serder.prior().clone().unwrap_or_default();
2027
2028        // Use StateEventBuilder to create the state record
2029        let state_builder = StateEventBuilder::new(
2030            prefixer.qb64(),                    // pre
2031            sner.num() as u64,                  // sn
2032            pig,                                // pig
2033            serder.said().unwrap().to_string(), // dig
2034            fner.num() as u64,                  // fn_
2035            self.ilk.to_string(),               // eilk
2036            keys,                               // keys
2037            eevt,                               // eevt
2038        )
2039        .with_stamp(dater.dts()) // stamp
2040        .with_sith(tholder.sith()) // sith
2041        .with_ndigs(ndigs) // ndigs
2042        .with_toad(toader.num() as usize) // toad
2043        .with_wits(wits) // wits
2044        .with_cnfg(cnfg); // cnfg
2045
2046        // Add next threshold if available
2047        let state_builder = match &self.ntholder {
2048            Some(ntholder) => state_builder.with_nsith(ntholder.sith()),
2049            None => state_builder,
2050        };
2051
2052        // Add delegator prefix if available
2053        let state_builder = match &self.delpre {
2054            Some(delpre) => state_builder.with_dpre(delpre.clone()),
2055            None => state_builder,
2056        };
2057
2058        // Build the state record
2059        let state_record = state_builder
2060            .build()
2061            .map_err(|e| KERIError::ValueError(e.to_string()))?;
2062
2063        Ok(state_record)
2064    }
2065
2066    fn tholder(&self) -> Option<Tholder> {
2067        self.tholder.clone()
2068    }
2069
2070    pub fn toader(&self) -> Option<Number> {
2071        self.toader.clone()
2072    }
2073
2074    pub fn wits(&self) -> Vec<String> {
2075        self.wits.clone().unwrap_or_else(Vec::new)
2076    }
2077
2078    pub fn prefixer(&self) -> Option<Prefixer> {
2079        self.prefixer.clone()
2080    }
2081
2082    pub fn serder(&self) -> Option<SerderKERI> {
2083        self.serder.clone()
2084    }
2085
2086    pub fn delpre(&self) -> Option<String> {
2087        self.delpre.clone()
2088    }
2089
2090    fn ndigs(&self) -> Vec<String> {
2091        if self.ndigers.is_none() {
2092            Vec::new()
2093        } else {
2094            self.ndigers
2095                .clone()
2096                .unwrap()
2097                .iter()
2098                .map(|d| d.qb64())
2099                .collect()
2100        }
2101    }
2102
2103    /// Returns either the most recent prior list of digers before .last_est or None
2104    ///
2105    /// Starts searching at sn or if sn is None at sn = .last_est.s - 1
2106    ///
2107    /// Returns list of Digers instances at the most recent prior est event relative
2108    /// to the given sequence number (sn) otherwise returns None.
2109    /// Walks backwards to the more recent prior establishment event before the
2110    /// .sn if any.
2111    /// If sn represents an interaction event (ixn) then the result will be the
2112    /// current valid list of digers. If sn represents an establishment event then
2113    /// the result will be the list of digers immediately prior to the current list.
2114    ///
2115    /// # Arguments
2116    ///
2117    /// * `sn` - Optional sequence number to start searching. If None then start at .last_est.s - 1
2118    ///
2119    /// # Returns
2120    ///
2121    /// * `Result<Option<Vec<Diger>>, KERIError>` - Vector of Diger instances or None if no prior est evt
2122    ///    to current .last_est
2123    pub fn fetch_prior_digers(&self, sn: Option<u64>) -> Result<Option<Vec<Diger>>, KERIError> {
2124        // Get the prefix from the prefixer
2125        let pre = match &self.prefixer {
2126            Some(prefixer) => prefixer.qb64(),
2127            None => return Err(KERIError::ValidationError("Missing prefixer".to_string())),
2128        };
2129
2130        // Determine the starting sequence number
2131        let start_sn = match sn {
2132            Some(s) => s,
2133            None => match &self.last_est {
2134                Some(last_est) => {
2135                    if last_est.s > 0 {
2136                        last_est.s - 1
2137                    } else {
2138                        return Ok(None);
2139                    }
2140                }
2141                None => return Ok(None),
2142            },
2143        };
2144
2145        // Iterate backwards through the KEL from the starting sequence number
2146        let kel_back_iter = self
2147            .db
2148            .kels
2149            .get_on_back_iter::<_, Vec<u8>>(&[&pre], start_sn as u32)?;
2150
2151        for digb in kel_back_iter {
2152            // Create the digest key for the event
2153            let dgkey = dg_key(&pre, &digb?);
2154
2155            // Get the event data
2156            let raw = match self.db.evts.get::<_, Vec<u8>>(&[dgkey]) {
2157                Ok(evt) => evt,
2158                Err(_) => return Ok(None),
2159            };
2160
2161            // Parse the event
2162            let serder = SerderKERI::from_raw(&Vec::from(raw.unwrap()), None)?;
2163
2164            // Check if this is an establishment event
2165            if serder.estive() {
2166                // Return the next digests from this event
2167                return Ok(serder.ndigers());
2168            }
2169        }
2170
2171        // No prior establishment event found
2172        Ok(None)
2173    }
2174
2175    pub fn transferable(&self) -> bool {
2176        match &self.prefixer {
2177            Some(prefixer) => {
2178                self.ndigers.is_some()
2179                    && self.ndigers.clone().unwrap().len() > 0
2180                    && prefixer.transferable()
2181            }
2182            None => false,
2183        }
2184    }
2185}
2186
2187/// KeverBuilder provides a builder pattern for constructing a Kever instance
2188/// Each optional parameter of Kever::new is represented by a with_* method
2189pub struct KeverBuilder {
2190    db: Arc<Baser>,
2191    locals: Locals,
2192    state: Option<KeyStateRecord>,
2193    serder: Option<SerderKERI>,
2194    sigers: Option<Vec<Siger>>,
2195    wigers: Option<Vec<Siger>>,
2196    est_only: Option<bool>,
2197    delseqner: Option<Seqner>,
2198    delsaider: Option<Saider>,
2199    firner: Option<Seqner>,
2200    dater: Option<Dater>,
2201    eager: Option<bool>,
2202    local: Option<bool>,
2203    check: Option<bool>,
2204}
2205
2206impl KeverBuilder {
2207    /// Create a new KeverBuilder with required database
2208    pub fn new(db: Arc<Baser>) -> Self {
2209        KeverBuilder {
2210            db,
2211            locals: Locals::default(),
2212            state: None,
2213            serder: None,
2214            sigers: None,
2215            wigers: None,
2216            est_only: None,
2217            delseqner: None,
2218            delsaider: None,
2219            firner: None,
2220            dater: None,
2221            eager: None,
2222            local: None,
2223            check: None,
2224        }
2225    }
2226
2227    /// Set the locally controlled identifiers used during validation
2228    pub fn with_locals(mut self, locals: Locals) -> Self {
2229        self.locals = locals;
2230        self
2231    }
2232
2233    /// Set the key state record
2234    pub fn with_state(mut self, state: KeyStateRecord) -> Self {
2235        self.state = Some(state);
2236        self
2237    }
2238
2239    /// Set the serialized event data
2240    pub fn with_serder(mut self, serder: SerderKERI) -> Self {
2241        self.serder = Some(serder);
2242        self
2243    }
2244
2245    /// Set the list of indexed controller signatures
2246    pub fn with_sigers(mut self, sigers: Vec<Siger>) -> Self {
2247        self.sigers = Some(sigers);
2248        self
2249    }
2250
2251    /// Set the list of indexed witness signatures
2252    pub fn with_wigers(mut self, wigers: Vec<Siger>) -> Self {
2253        self.wigers = Some(wigers);
2254        self
2255    }
2256
2257    /// Set the establishment only events flag
2258    pub fn with_est_only(mut self, est_only: bool) -> Self {
2259        self.est_only = Some(est_only);
2260        self
2261    }
2262
2263    /// Set the delegating event sequence number
2264    pub fn with_delseqner(mut self, delseqner: Seqner) -> Self {
2265        self.delseqner = Some(delseqner);
2266        self
2267    }
2268
2269    /// Set the delegating event SAID
2270    pub fn with_delsaider(mut self, delsaider: Saider) -> Self {
2271        self.delsaider = Some(delsaider);
2272        self
2273    }
2274
2275    /// Set the first seen ordinal number
2276    pub fn with_firner(mut self, firner: Seqner) -> Self {
2277        self.firner = Some(firner);
2278        self
2279    }
2280
2281    /// Set the first seen timestamp
2282    pub fn with_dater(mut self, dater: Dater) -> Self {
2283        self.dater = Some(dater);
2284        self
2285    }
2286
2287    /// Set the eager validation flag
2288    pub fn with_eager(mut self, eager: bool) -> Self {
2289        self.eager = Some(eager);
2290        self
2291    }
2292
2293    /// Set the local flag for event source validation logic
2294    pub fn with_local(mut self, local: bool) -> Self {
2295        self.local = Some(local);
2296        self
2297    }
2298
2299    /// Set the check flag for database update control
2300    pub fn with_check(mut self, check: bool) -> Self {
2301        self.check = Some(check);
2302        self
2303    }
2304
2305    /// Build the Kever instance
2306    pub fn build(self) -> Result<Kever, KERIError> {
2307        Kever::new(
2308            self.db,
2309            &self.locals,
2310            self.state,
2311            self.serder,
2312            self.sigers,
2313            self.wigers,
2314            self.est_only,
2315            self.delseqner,
2316            self.delsaider,
2317            self.firner,
2318            self.dater,
2319            self.eager,
2320            self.local,
2321            self.check,
2322        )
2323    }
2324}
2325
2326#[cfg(test)]
2327mod tests {
2328    use super::*;
2329    use crate::cesr::diger::Diger;
2330    use crate::cesr::signing::{Salter, Sigmat};
2331    use crate::cesr::tholder::TholderThold;
2332    use crate::cesr::{mtr_dex, pre_dex};
2333    use crate::keri::core::eventing::interact::InteractEventBuilder;
2334    use crate::keri::core::eventing::rotate::RotateEventBuilder;
2335    use crate::keri::core::eventing::InceptionEventBuilder;
2336    use crate::keri::core::serdering::SadValue;
2337    use crate::keri::db::dbing::LMDBer;
2338    use crate::keri::KERIError;
2339    use std::collections::HashMap;
2340    use std::sync::Arc;
2341
2342    #[test]
2343    fn test_kever() -> Result<(), KERIError> {
2344        Ok(())
2345    }
2346
2347    #[test]
2348    fn test_kever_builder() -> Result<(), KERIError> {
2349        // This test would need proper test fixtures to be meaningful
2350        // Just showing example usage
2351        let lmdber = LMDBer::builder()
2352            .name("temp")
2353            .reopen(true)
2354            .build()
2355            .expect("Failed to open Baser database: {}");
2356        let db = Baser::new(Arc::new(lmdber)).expect("Failed to create manager database");
2357
2358        let raw = [
2359            0x05, 0xaa, 0x8f, 0x2d, 0x53, 0x9a, 0xe9, 0xfa, 0x55, 0x9c, 0x02, 0x9c, 0x9b, 0x08,
2360            0x48, 0x75,
2361        ];
2362        let salter = Salter::new(Some(&raw), None, None)?;
2363
2364        // Create current key (one signer)
2365        let sith = 1;
2366        let skp0 = salter.signer(None, Some(true), "A", None, true)?;
2367        assert_eq!(skp0.code(), mtr_dex::ED25519_SEED);
2368        assert_eq!(skp0.verfer().code(), mtr_dex::ED25519);
2369        assert_eq!(
2370            skp0.verfer().qb64(),
2371            "DAUDqkmn-hqlQKD8W-FAEa5JUvJC2I9yarEem-AAEg3e"
2372        );
2373        let keys = vec![skp0.verfer().qb64()];
2374
2375        // Create next key (transferable by default)
2376        let skp1 = salter.signer(None, Some(true), "N", None, true)?;
2377        assert_eq!(skp1.code(), mtr_dex::ED25519_SEED);
2378        assert_eq!(skp1.verfer().code(), mtr_dex::ED25519);
2379
2380        // Compute next digest
2381        let ndiger = Diger::from_ser(skp1.verfer().qb64b().as_slice(), None)?;
2382        let nxt = vec![ndiger.qb64()];
2383        assert_eq!(nxt, vec!["EAKUR-LmLHWMwXTLWQ1QjxHrihBmwwrV2tYaSG7hOrWj"]);
2384
2385        // Set up initial values
2386        let sn = 0; // Inception event
2387        let toad = 0; // No witnesses
2388        let nsigs = 1; // One attached signature
2389
2390        // Creating the event serialization with non-digestive prefix
2391        let mut saids = HashMap::new();
2392        saids.insert("i", pre_dex::ED25519.to_string());
2393
2394        let mut serder = SerderKERI::new(
2395            None,           // raw
2396            None,           // sad
2397            Some(true),     // makify
2398            None,           //smellage
2399            None,           // proto
2400            None,           // version
2401            None,           // kind
2402            Some(Ilk::Icp), // ilk
2403            Some(saids),    // saids
2404        )?;
2405
2406        // Get sad and modify it
2407        let mut sad = serder.sad();
2408
2409        // Update sad with required fields
2410        sad.insert("i".to_string(), SadValue::from_string(skp0.verfer().qb64()));
2411        sad.insert("s".to_string(), SadValue::from_string(format!("{:x}", sn)));
2412        sad.insert(
2413            "kt".to_string(),
2414            SadValue::from_string(format!("{:x}", sith)),
2415        );
2416        sad.insert(
2417            "k".to_string(),
2418            SadValue::from_array(
2419                keys.iter()
2420                    .map(|k| SadValue::from_string(k.clone()))
2421                    .collect::<Vec<_>>(),
2422            ),
2423        );
2424        sad.insert("nt".to_string(), SadValue::from_u64(1));
2425        sad.insert(
2426            "n".to_string(),
2427            SadValue::from_array(
2428                nxt.iter()
2429                    .map(|n| SadValue::from_string(n.clone()))
2430                    .collect::<Vec<_>>(),
2431            ),
2432        );
2433        sad.insert(
2434            "bt".to_string(),
2435            SadValue::from_string(format!("{:x}", toad)),
2436        );
2437
2438        // Create new serder with the updated sad and verify it
2439        let mut saids_for_verification = HashMap::new();
2440        saids_for_verification.insert("i", pre_dex::ED25519.to_string());
2441
2442        serder = SerderKERI::new(
2443            None,
2444            Some(&sad),
2445            Some(true),
2446            None,
2447            None,
2448            None,
2449            None,
2450            None,
2451            Some(saids_for_verification),
2452        )?; // sad with updates
2453
2454        // Verify the said and pre values
2455        assert_eq!(
2456            serder.said().unwrap(),
2457            "EBTCANzIfUThxmM1z1SFxQuwooGdF4QwtotRS01vZGqi"
2458        );
2459        assert_eq!(
2460            serder.pre().unwrap(),
2461            "DAUDqkmn-hqlQKD8W-FAEa5JUvJC2I9yarEem-AAEg3e"
2462        );
2463        let aid0 = serder.pre().unwrap();
2464
2465        // Assign first serialization
2466        let tser0 = serder.clone();
2467
2468        // Sign serialization
2469        let tsig0 = skp0.sign(tser0.raw(), Some(0), None, None)?;
2470
2471        // Get the siger from the signature result
2472        let tsig0 = match tsig0 {
2473            Sigmat::Indexed(siger) => siger,
2474            _ => {
2475                return Err(KERIError::ValueError(
2476                    "Expected indexed signature".to_string(),
2477                ))
2478            }
2479        };
2480
2481        // Verify signature
2482        assert!(skp0.verfer().verify(tsig0.raw(), tser0.raw())?);
2483
2484        // Create the Kever
2485        let kever = KeverBuilder::new(Arc::new(db))
2486            .with_serder(tser0.clone())
2487            .with_sigers(vec![tsig0])
2488            .build()?;
2489
2490        // Verify Kever properties
2491        assert_eq!(kever.prefixer().unwrap().qb64(), aid0);
2492
2493        // These assertions would need proper implementation
2494        assert_eq!(kever.sner.clone().unwrap().num(), 0);
2495        assert_eq!(
2496            kever
2497                .verfers
2498                .clone()
2499                .unwrap()
2500                .iter()
2501                .map(|v| v.qb64())
2502                .collect::<Vec<_>>(),
2503            vec![skp0.verfer().qb64()]
2504        );
2505        assert_eq!(kever.ndigs().clone(), nxt);
2506        let prefixer = kever
2507            .prefixer()
2508            .ok_or_else(|| KERIError::ValueError("Missing prefixer in Kever".to_string()))?;
2509
2510        // Test getting state from the database
2511        let state: KeyStateRecord = kever
2512            .db
2513            .states
2514            .get(&[&prefixer.qb64()])
2515            .expect("State not found")
2516            .unwrap();
2517
2518        // Get the sequence number from kever
2519        let sner = kever
2520            .sner
2521            .as_ref()
2522            .ok_or_else(|| KERIError::ValueError("Missing sner in Kever".to_string()))?;
2523
2524        // Format sner.num as hex string for comparison
2525        let sner_hex = format!("{:x}", sner.num());
2526
2527        // Test that state's sequence number matches kever's
2528        assert_eq!(state.s, sner_hex);
2529        assert_eq!(state.s, "0"); // Assert sequence is 0
2530
2531        // Get the serder from kever
2532        let serder = kever
2533            .serder
2534            .as_ref()
2535            .ok_or_else(|| KERIError::ValueError("Missing serder in Kever".to_string()))?;
2536
2537        // Test getting feqner (first seen ordinal) from db
2538        let feqner: Number = kever
2539            .db
2540            .fons
2541            .get(&[&prefixer.qb64(), &serder.said().unwrap().to_string()])?
2542            .unwrap();
2543
2544        // Compare feqner's sequence number with kever's
2545        assert_eq!(feqner.num(), kever.sner.as_ref().unwrap().num());
2546
2547        // Get state record from kever
2548        let ksr = kever.state()?;
2549
2550        // Test that state from db matches state from kever.state()
2551        assert_eq!(ksr, state);
2552
2553        // Test that identifier prefix matches
2554        assert_eq!(ksr.i, prefixer.qb64());
2555
2556        // Test that sequence number matches
2557        assert_eq!(ksr.s, sner_hex);
2558
2559        // Get verfers from kever
2560        let verfers = kever
2561            .verfers
2562            .as_ref()
2563            .ok_or_else(|| KERIError::ValueError("Missing verfers in Kever".to_string()))?;
2564
2565        // Extract keys from state record
2566        let state_keys = ksr.k;
2567
2568        // Extract qb64 keys from verfers
2569        let verfer_keys: Vec<String> = verfers.iter().map(|verfer| verfer.qb64()).collect();
2570
2571        // Compare keys from state with keys from verfers
2572        assert_eq!(state_keys, verfer_keys);
2573        Ok(())
2574    }
2575
2576    #[test]
2577    fn test_kever_missing_args() -> Result<(), KERIError> {
2578        // Test creating a Kever without required arguments should fail
2579        // This would need a proper database implementation for testing
2580        let lmdber = LMDBer::builder()
2581            .name("temp")
2582            .reopen(true)
2583            .build()
2584            .expect("Failed to open Baser database: {}");
2585        let db = Baser::new(Arc::new(lmdber)).expect("Failed to create manager database");
2586
2587        let result = KeverBuilder::new(Arc::new(db)).build();
2588
2589        assert!(result.is_err());
2590        match result {
2591            Err(KERIError::ValueError(msg)) => {
2592                assert!(msg.contains("Missing required arguments"));
2593                Ok(())
2594            }
2595            _ => Err(KERIError::ValueError(
2596                "Expected ValueError for missing arguments".to_string(),
2597            )),
2598        }
2599    }
2600
2601    #[test]
2602    fn test_keyeventsequence_0() -> Result<(), KERIError> {
2603        // Test generation of a sequence of key events
2604
2605        // Create salt and signers
2606        let salt = b"g\x15\x89\x1a@\xa4\xa47\x07\xb9Q\xb8\x18\xcdJW";
2607        let salter = Salter::new(Some(salt), None, None)?;
2608        let signers = salter.signers(8, 0, "", None, None, None, false)?;
2609
2610        // Extract public keys
2611        let pubkeys: Vec<String> = signers.iter().map(|s| s.verfer().qb64()).collect();
2612
2613        // Assert public keys match expected values
2614        assert_eq!(
2615            pubkeys,
2616            vec![
2617                "DErocgXD2RGSyvn3MObcx59jeOsEQhv2TqHirVkzrp0Q".to_string(),
2618                "DFXLiTjiRdSBPLL6hLa0rskIxk3dh4XwJLfctkJFLRSS".to_string(),
2619                "DE9YgIQVgpLwocTVrG8tidKScsQSMWwLWywNC48fhq4f".to_string(),
2620                "DCjxOXniUc5EUzDqERlXdptfKPHy6jNo_ZGsS4Vd8fAE".to_string(),
2621                "DNZHARO4dCJlluv0qezEMRmErIWWc-lzOzolBOQ15tHV".to_string(),
2622                "DOCQ4KN1jUlKbfjRteDYt9fxgpq1NK9_MqO5IA7shpED".to_string(),
2623                "DFY1nGjV9oApBzo5Oq5JqjwQsZEQqsCCftzo3WJjMMX-".to_string(),
2624                "DE9ZxA3qXegkgDAhOzWP45S3Ruv5ilJSkv5lvthyWNYY".to_string(),
2625            ]
2626        );
2627
2628        let lmdber = LMDBer::builder()
2629            .name("temp")
2630            .reopen(true)
2631            .build()
2632            .expect("Failed to open Baser database: {}");
2633        let db = Baser::new(Arc::new(lmdber)).expect("Failed to create manager database");
2634
2635        // List to store event digests
2636        let mut event_digs = Vec::new();
2637
2638        // Event 0 - Inception Transferable (nxt digest not empty)
2639        let keys0 = vec![signers[0].verfer().qb64()];
2640
2641        // Compute nxt digest from keys1
2642        let keys1 = vec![signers[1].verfer().qb64()];
2643        let ndiger1 = Diger::from_ser(&signers[1].verfer().qb64b(), None)?;
2644        let nxt1 = vec![ndiger1.qb64()];
2645
2646        // Verify next digest matches expected value
2647        assert_eq!(
2648            nxt1,
2649            vec!["EIQsSW4KMrLzY1HQI9H_XxY6MyzhaFFXhG6fdBb5Wxta".to_string()]
2650        );
2651
2652        // Create inception event
2653
2654        let serder0 = InceptionEventBuilder::new(keys0.clone())
2655            .with_ndigs(nxt1.clone())
2656            .build()?;
2657        let pre = serder0.pre().unwrap();
2658        event_digs.push(serder0.said().unwrap().to_string());
2659
2660        // Verify event properties
2661        assert_eq!(serder0.pre().unwrap(), signers[0].verfer().qb64());
2662        assert_eq!(serder0.ked()["s"].as_str(), Some("0"));
2663        assert_eq!(serder0.ked()["kt"].as_str(), Some("1"));
2664        assert_eq!(
2665            serder0.ked()["k"].as_array(),
2666            Some(
2667                &keys0
2668                    .iter()
2669                    .map(|k| SadValue::String(k.to_string()))
2670                    .collect::<Vec<SadValue>>()
2671            )
2672        );
2673        assert_eq!(
2674            serder0.ked()["n"].as_array(),
2675            Some(
2676                &nxt1
2677                    .iter()
2678                    .map(|n| SadValue::String(n.to_string()))
2679                    .collect::<Vec<SadValue>>()
2680            )
2681        );
2682        assert_eq!(
2683            serder0.said().unwrap(),
2684            "ECLgCt_5bprUe0SF1XCR94Zo5ShSEZO8cLf0dH3pwZxU"
2685        );
2686
2687        // Sign the serialization
2688        let sig0 = match signers[0].sign(serder0.raw(), Some(0), None, None)? {
2689            Sigmat::Indexed(siger) => siger,
2690            _ => {
2691                return Err(KERIError::ValueError(
2692                    "Expected indexed signature".to_string(),
2693                ))
2694            }
2695        };
2696
2697        // Verify signature
2698        assert!(signers[0].verfer().verify(sig0.raw(), serder0.raw())?);
2699
2700        // Create Kever with the event
2701        let mut kever = KeverBuilder::new(Arc::new(db))
2702            .with_serder(serder0.clone())
2703            .with_sigers(vec![sig0])
2704            .build()?;
2705
2706        // Verify Kever state
2707        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
2708        assert_eq!(kever.sner.as_ref().unwrap().num(), 0u128);
2709        assert_eq!(
2710            kever.serder.as_ref().unwrap().said().unwrap(),
2711            event_digs[0]
2712        );
2713        assert_eq!(kever.ilk, Ilk::Icp);
2714        assert_eq!(
2715            kever.tholder.clone().unwrap().thold(),
2716            &TholderThold::Integer(1)
2717        );
2718
2719        // Verify verfers in Kever match keys0
2720        let kever_verfers: Vec<String> = kever
2721            .verfers
2722            .as_ref()
2723            .unwrap()
2724            .iter()
2725            .map(|v| v.qb64())
2726            .collect();
2727        assert_eq!(kever_verfers, keys0);
2728
2729        // Verify ndigs in Kever
2730        assert_eq!(kever.ndigs().clone(), nxt1);
2731
2732        // Verify transferable and estOnly flags
2733        assert_eq!(kever.est_only, Some(false));
2734        assert!(kever.prefixer.as_ref().unwrap().transferable());
2735
2736        let pigers = kever.fetch_prior_digers(None)?;
2737        assert!(pigers.is_none());
2738
2739        // Event 1 Rotation Transferable
2740        // compute nxt digest from keys2
2741        let keys2 = vec![signers[2].verfer().qb64()];
2742        let ndiger2 = Diger::from_ser(&signers[2].verfer().qb64b(), None)?;
2743        let nxt2 = vec![ndiger2.qb64()];
2744        assert_eq!(
2745            nxt2,
2746            vec!["EHuvLs1hmwxo4ImDoCpaAermYVQhiPsPDNaZsz4bcgko".to_string()]
2747        );
2748
2749        let serder1 = RotateEventBuilder::new(
2750            pre.clone(),
2751            keys1.clone(),
2752            serder0.said().unwrap().to_string(),
2753        )
2754        .with_sn(1)
2755        .with_ndigs(nxt2.clone())
2756        .build()?;
2757
2758        event_digs.push(serder1.said().unwrap().to_string());
2759
2760        assert_eq!(serder1.ked()["i"].as_str().unwrap(), pre);
2761        assert_eq!(serder1.ked()["s"].as_str().unwrap(), "1");
2762        assert_eq!(serder1.ked()["kt"].as_str().unwrap(), "1");
2763        assert_eq!(
2764            serder1.ked()["k"]
2765                .as_array()
2766                .unwrap()
2767                .iter()
2768                .map(|v| v.as_str().unwrap())
2769                .collect::<Vec<&str>>(),
2770            keys1
2771        );
2772        assert_eq!(
2773            serder1.ked()["n"]
2774                .as_array()
2775                .unwrap()
2776                .iter()
2777                .map(|v| v.as_str().unwrap())
2778                .collect::<Vec<&str>>(),
2779            nxt2
2780        );
2781        assert_eq!(
2782            serder1.ked()["p"].as_str().unwrap(),
2783            serder0.said().unwrap()
2784        );
2785
2786        // sign serialization and verify signature
2787        let sig1 = match signers[1].sign(serder1.raw(), Some(0), None, None)? {
2788            Sigmat::Indexed(siger) => siger,
2789            _ => {
2790                return Err(KERIError::ValueError(
2791                    "Expected indexed signature".to_string(),
2792                ))
2793            }
2794        };
2795        assert!(signers[1].verfer().verify(sig1.raw(), serder1.raw())?);
2796
2797        // update key event verifier state
2798        kever.update(
2799            &Locals::default(),
2800            serder1.clone(),
2801            vec![sig1],
2802            None,
2803            None,
2804            None,
2805            None,
2806            None,
2807            false,
2808            false,
2809            false,
2810        )?;
2811        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
2812        assert_eq!(kever.sner.as_ref().unwrap().num(), 1u128);
2813        assert_eq!(
2814            kever.serder.as_ref().unwrap().said().unwrap(),
2815            event_digs[1]
2816        );
2817        assert_eq!(kever.ilk, Ilk::Rot);
2818
2819        // Verify verfers in Kever match keys1
2820        let kever_verfers: Vec<String> = kever
2821            .verfers
2822            .as_ref()
2823            .unwrap()
2824            .iter()
2825            .map(|v| v.qb64())
2826            .collect();
2827        assert_eq!(kever_verfers, keys1);
2828
2829        // Verify ndigs in Kever
2830        assert_eq!(kever.ndigs().clone(), nxt2);
2831
2832        let pigers = kever.fetch_prior_digers(None)?;
2833        assert!(pigers.is_some());
2834        let pigers_qb64: Vec<String> = pigers.unwrap().iter().map(|d| d.qb64()).collect();
2835        assert_eq!(pigers_qb64, nxt1);
2836
2837        // Event 2 Rotation Transferable
2838        // compute nxt digest from keys3
2839        let keys3 = vec![signers[3].verfer().qb64()];
2840        let ndiger3 = Diger::from_ser(&signers[3].verfer().qb64b(), None)?;
2841        let nxt3 = vec![ndiger3.qb64()];
2842
2843        let serder2 = RotateEventBuilder::new(
2844            pre.clone(),
2845            keys2.clone(),
2846            serder1.said().unwrap().to_string(),
2847        )
2848        .with_sn(2)
2849        .with_ndigs(nxt3.clone())
2850        .build()?;
2851
2852        event_digs.push(serder2.said().unwrap().to_string());
2853
2854        assert_eq!(serder2.ked()["i"].as_str().unwrap(), pre);
2855        assert_eq!(serder2.ked()["s"].as_str().unwrap(), "2");
2856        assert_eq!(
2857            serder2.ked()["k"]
2858                .as_array()
2859                .unwrap()
2860                .iter()
2861                .map(|v| v.as_str().unwrap())
2862                .collect::<Vec<&str>>(),
2863            keys2
2864        );
2865        assert_eq!(
2866            serder2.ked()["n"]
2867                .as_array()
2868                .unwrap()
2869                .iter()
2870                .map(|v| v.as_str().unwrap())
2871                .collect::<Vec<&str>>(),
2872            nxt3
2873        );
2874        assert_eq!(
2875            serder2.ked()["p"].as_str().unwrap(),
2876            serder1.said().unwrap()
2877        );
2878
2879        // sign serialization and verify signature
2880        let sig2 = match signers[2].sign(serder2.raw(), Some(0), None, None)? {
2881            Sigmat::Indexed(siger) => siger,
2882            _ => {
2883                return Err(KERIError::ValueError(
2884                    "Expected indexed signature".to_string(),
2885                ))
2886            }
2887        };
2888        assert!(signers[2].verfer().verify(sig2.raw(), serder2.raw())?);
2889
2890        // update key event verifier state
2891        kever.update(
2892            &Locals::default(),
2893            serder2.clone(),
2894            vec![sig2],
2895            None,
2896            None,
2897            None,
2898            None,
2899            None,
2900            false,
2901            false,
2902            false,
2903        )?;
2904        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
2905        assert_eq!(kever.sner.as_ref().unwrap().num(), 2u128);
2906        assert_eq!(
2907            kever.serder.as_ref().unwrap().said().unwrap(),
2908            event_digs[2]
2909        );
2910        assert_eq!(kever.ilk, Ilk::Rot);
2911
2912        // Verify verfers in Kever match keys2
2913        let kever_verfers: Vec<String> = kever
2914            .verfers
2915            .as_ref()
2916            .unwrap()
2917            .iter()
2918            .map(|v| v.qb64())
2919            .collect();
2920        assert_eq!(kever_verfers, keys2);
2921
2922        // Verify ndigs in Kever
2923        assert_eq!(kever.ndigs().clone(), nxt3);
2924
2925        let pigers = kever.fetch_prior_digers(None)?;
2926        assert!(pigers.is_some());
2927        let pigers_qb64: Vec<String> = pigers.unwrap().iter().map(|d| d.qb64()).collect();
2928        assert_eq!(pigers_qb64, nxt2);
2929
2930        // Event 3 Interaction
2931        let serder3 = InteractEventBuilder::new(pre.clone(), serder2.said().unwrap().to_string())
2932            .with_sn(3)
2933            .build()?;
2934
2935        event_digs.push(serder3.said().unwrap().to_string());
2936
2937        assert_eq!(serder3.ked()["i"].as_str().unwrap(), pre);
2938        assert_eq!(serder3.ked()["s"].as_str().unwrap(), "3");
2939        assert_eq!(
2940            serder3.ked()["p"].as_str().unwrap(),
2941            serder2.said().unwrap()
2942        );
2943
2944        // sign serialization and verify signature
2945        let sig3 = match signers[2].sign(serder3.raw(), Some(0), None, None)? {
2946            Sigmat::Indexed(siger) => siger,
2947            _ => {
2948                return Err(KERIError::ValueError(
2949                    "Expected indexed signature".to_string(),
2950                ))
2951            }
2952        };
2953        assert!(signers[2].verfer().verify(sig3.raw(), serder3.raw())?);
2954
2955        // update key event verifier state
2956        kever.update(
2957            &Locals::default(),
2958            serder3.clone(),
2959            vec![sig3],
2960            None,
2961            None,
2962            None,
2963            None,
2964            None,
2965            false,
2966            false,
2967            false,
2968        )?;
2969        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
2970        assert_eq!(kever.sner.as_ref().unwrap().num(), 3u128);
2971        assert_eq!(
2972            kever.serder.as_ref().unwrap().said().unwrap(),
2973            event_digs[3]
2974        );
2975        assert_eq!(kever.ilk, Ilk::Ixn);
2976
2977        // Verify verfers in Kever match keys2 (no change)
2978        let kever_verfers: Vec<String> = kever
2979            .verfers
2980            .as_ref()
2981            .unwrap()
2982            .iter()
2983            .map(|v| v.qb64())
2984            .collect();
2985        assert_eq!(kever_verfers, keys2);
2986
2987        // Verify ndigs in Kever (no change)
2988        assert_eq!(kever.ndigs().clone(), nxt3);
2989
2990        let pigers = kever.fetch_prior_digers(None)?;
2991        assert!(pigers.is_some());
2992        let pigers_qb64: Vec<String> = pigers.unwrap().iter().map(|d| d.qb64()).collect();
2993        assert_eq!(pigers_qb64, nxt2); // digs from rot before rot before ixn
2994
2995        // Event 4 Interaction
2996        let serder4 = InteractEventBuilder::new(pre.clone(), serder3.said().unwrap().to_string())
2997            .with_sn(4)
2998            .build()?;
2999
3000        event_digs.push(serder4.said().unwrap().to_string());
3001
3002        assert_eq!(serder4.ked()["i"].as_str().unwrap(), pre);
3003        assert_eq!(serder4.ked()["s"].as_str().unwrap(), "4");
3004        assert_eq!(
3005            serder4.ked()["p"].as_str().unwrap(),
3006            serder3.said().unwrap()
3007        );
3008
3009        // sign serialization and verify signature
3010        let sig4 = match signers[2].sign(serder4.raw(), Some(0), None, None)? {
3011            Sigmat::Indexed(siger) => siger,
3012            _ => {
3013                return Err(KERIError::ValueError(
3014                    "Expected indexed signature".to_string(),
3015                ))
3016            }
3017        };
3018        assert!(signers[2].verfer().verify(sig4.raw(), serder4.raw())?);
3019
3020        // update key event verifier state
3021        kever.update(
3022            &Locals::default(),
3023            serder4.clone(),
3024            vec![sig4],
3025            None,
3026            None,
3027            None,
3028            None,
3029            None,
3030            false,
3031            false,
3032            false,
3033        )?;
3034        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
3035        assert_eq!(kever.sner.as_ref().unwrap().num(), 4u128);
3036        assert_eq!(
3037            kever.serder.as_ref().unwrap().said().unwrap(),
3038            event_digs[4]
3039        );
3040        assert_eq!(kever.ilk, Ilk::Ixn);
3041
3042        // Verify verfers in Kever match keys2 (no change)
3043        let kever_verfers: Vec<String> = kever
3044            .verfers
3045            .as_ref()
3046            .unwrap()
3047            .iter()
3048            .map(|v| v.qb64())
3049            .collect();
3050        assert_eq!(kever_verfers, keys2);
3051
3052        // Verify ndigs in Kever (no change)
3053        assert_eq!(kever.ndigs().clone(), nxt3);
3054
3055        let pigers = kever.fetch_prior_digers(None)?;
3056        assert!(pigers.is_some());
3057        let pigers_qb64: Vec<String> = pigers.unwrap().iter().map(|d| d.qb64()).collect();
3058        assert_eq!(pigers_qb64, nxt2); // digs from rot before rot before ixn ixn
3059
3060        // Event 5 Rotation Transferable
3061        // compute nxt digest from keys4
3062        let keys4 = vec![signers[4].verfer().qb64()];
3063        let ndiger4 = Diger::from_ser(&signers[4].verfer().qb64b(), None)?;
3064        let nxt4 = vec![ndiger4.qb64()];
3065
3066        let serder5 = RotateEventBuilder::new(
3067            pre.clone(),
3068            keys3.clone(),
3069            serder4.said().unwrap().to_string(),
3070        )
3071        .with_sn(5)
3072        .with_ndigs(nxt4.clone())
3073        .build()?;
3074
3075        event_digs.push(serder5.said().unwrap().to_string());
3076
3077        assert_eq!(serder5.ked()["i"].as_str().unwrap(), pre);
3078        assert_eq!(serder5.ked()["s"].as_str().unwrap(), "5");
3079        assert_eq!(
3080            serder5.ked()["k"]
3081                .as_array()
3082                .unwrap()
3083                .iter()
3084                .map(|v| v.as_str().unwrap())
3085                .collect::<Vec<&str>>(),
3086            keys3
3087        );
3088        assert_eq!(
3089            serder5.ked()["n"]
3090                .as_array()
3091                .unwrap()
3092                .iter()
3093                .map(|v| v.as_str().unwrap())
3094                .collect::<Vec<&str>>(),
3095            nxt4
3096        );
3097        assert_eq!(
3098            serder5.ked()["p"].as_str().unwrap(),
3099            serder4.said().unwrap()
3100        );
3101
3102        // sign serialization and verify signature
3103        let sig5 = match signers[3].sign(serder5.raw(), Some(0), None, None)? {
3104            Sigmat::Indexed(siger) => siger,
3105            _ => {
3106                return Err(KERIError::ValueError(
3107                    "Expected indexed signature".to_string(),
3108                ))
3109            }
3110        };
3111        assert!(signers[3].verfer().verify(sig5.raw(), serder5.raw())?);
3112
3113        // update key event verifier state
3114        kever.update(
3115            &Locals::default(),
3116            serder5.clone(),
3117            vec![sig5],
3118            None,
3119            None,
3120            None,
3121            None,
3122            None,
3123            false,
3124            false,
3125            false,
3126        )?;
3127        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
3128        assert_eq!(kever.sner.as_ref().unwrap().num(), 5u128);
3129        assert_eq!(
3130            kever.serder.as_ref().unwrap().said().unwrap(),
3131            event_digs[5]
3132        );
3133        assert_eq!(kever.ilk, Ilk::Rot);
3134
3135        // Verify verfers in Kever match keys3
3136        let kever_verfers: Vec<String> = kever
3137            .verfers
3138            .as_ref()
3139            .unwrap()
3140            .iter()
3141            .map(|v| v.qb64())
3142            .collect();
3143        assert_eq!(kever_verfers, keys3);
3144
3145        // Verify ndigs in Kever
3146        assert_eq!(kever.ndigs().clone(), nxt4);
3147
3148        let pigers = kever.fetch_prior_digers(None)?;
3149        assert!(pigers.is_some());
3150        let pigers_qb64: Vec<String> = pigers.unwrap().iter().map(|d| d.qb64()).collect();
3151        assert_eq!(pigers_qb64, nxt3); // digs from rot before ixn ixn before rot
3152
3153        // Event 6 Interaction
3154        let serder6 = InteractEventBuilder::new(pre.clone(), serder5.said().unwrap().to_string())
3155            .with_sn(6)
3156            .build()?;
3157
3158        event_digs.push(serder6.said().unwrap().to_string());
3159
3160        assert_eq!(serder6.ked()["i"].as_str().unwrap(), pre);
3161        assert_eq!(serder6.ked()["s"].as_str().unwrap(), "6");
3162        assert_eq!(
3163            serder6.ked()["p"].as_str().unwrap(),
3164            serder5.said().unwrap()
3165        );
3166
3167        // sign serialization and verify signature
3168        let sig6 = match signers[3].sign(serder6.raw(), Some(0), None, None)? {
3169            Sigmat::Indexed(siger) => siger,
3170            _ => {
3171                return Err(KERIError::ValueError(
3172                    "Expected indexed signature".to_string(),
3173                ))
3174            }
3175        };
3176        assert!(signers[3].verfer().verify(sig6.raw(), serder6.raw())?);
3177
3178        // update key event verifier state
3179        kever.update(
3180            &Locals::default(),
3181            serder6.clone(),
3182            vec![sig6],
3183            None,
3184            None,
3185            None,
3186            None,
3187            None,
3188            false,
3189            false,
3190            false,
3191        )?;
3192        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
3193        assert_eq!(kever.sner.as_ref().unwrap().num(), 6u128);
3194        assert_eq!(
3195            kever.serder.as_ref().unwrap().said().unwrap(),
3196            event_digs[6]
3197        );
3198        assert_eq!(kever.ilk, Ilk::Ixn);
3199
3200        // Verify verfers in Kever match keys3 (no change)
3201        let kever_verfers: Vec<String> = kever
3202            .verfers
3203            .as_ref()
3204            .unwrap()
3205            .iter()
3206            .map(|v| v.qb64())
3207            .collect();
3208        assert_eq!(kever_verfers, keys3);
3209
3210        // Verify ndigs in Kever (no change)
3211        assert_eq!(kever.ndigs().clone(), nxt4);
3212
3213        // Event 7 Rotation to null NonTransferable Abandon
3214        let serder7 = RotateEventBuilder::new(
3215            pre.clone(),
3216            keys4.clone(),
3217            serder6.said().unwrap().to_string(),
3218        )
3219        .with_sn(7)
3220        .build()?; // Empty ndigs for non-transferable rotation
3221
3222        event_digs.push(serder7.said().unwrap().to_string());
3223
3224        assert_eq!(serder7.ked()["i"].as_str().unwrap(), pre);
3225        assert_eq!(serder7.ked()["s"].as_str().unwrap(), "7");
3226        assert_eq!(
3227            serder7.ked()["k"]
3228                .as_array()
3229                .unwrap()
3230                .iter()
3231                .map(|v| v.as_str().unwrap())
3232                .collect::<Vec<&str>>(),
3233            keys4
3234        );
3235        // Check for empty ndigs list
3236        assert_eq!(serder7.ked()["n"].as_array().unwrap().len(), 0);
3237        assert_eq!(
3238            serder7.ked()["p"].as_str().unwrap(),
3239            serder6.said().unwrap()
3240        );
3241
3242        // sign serialization and verify signature
3243        let sig7 = match signers[4].sign(serder7.raw(), Some(0), None, None)? {
3244            Sigmat::Indexed(siger) => siger,
3245            _ => {
3246                return Err(KERIError::ValueError(
3247                    "Expected indexed signature".to_string(),
3248                ))
3249            }
3250        };
3251        assert!(signers[4].verfer().verify(sig7.raw(), serder7.raw())?);
3252
3253        // update key event verifier state
3254        kever.update(
3255            &Locals::default(),
3256            serder7.clone(),
3257            vec![sig7],
3258            None,
3259            None,
3260            None,
3261            None,
3262            None,
3263            false,
3264            false,
3265            false,
3266        )?;
3267        assert_eq!(kever.prefixer.as_ref().unwrap().qb64(), pre);
3268        assert_eq!(kever.sner.as_ref().unwrap().num(), 7u128);
3269        assert_eq!(
3270            kever.serder.as_ref().unwrap().said().unwrap(),
3271            event_digs[7]
3272        );
3273        assert_eq!(kever.ilk, Ilk::Rot);
3274
3275        // Verify verfers in Kever match keys4
3276        let kever_verfers: Vec<String> = kever
3277            .verfers
3278            .as_ref()
3279            .unwrap()
3280            .iter()
3281            .map(|v| v.qb64())
3282            .collect();
3283        assert_eq!(kever_verfers, keys4);
3284
3285        // Verify ndigs in Kever are empty
3286        assert_eq!(kever.ndigs().len(), 0);
3287
3288        // Verify the identifier is no longer transferable
3289        assert!(!kever.transferable());
3290
3291        // Event 8 Interaction (should be rejected as identifier is non-transferable)
3292        let serder8 = InteractEventBuilder::new(pre.clone(), serder7.said().unwrap().to_string())
3293            .with_sn(8)
3294            .build()?;
3295
3296        assert_eq!(serder8.ked()["i"].as_str().unwrap(), pre);
3297        assert_eq!(serder8.ked()["s"].as_str().unwrap(), "8");
3298        assert_eq!(
3299            serder8.ked()["p"].as_str().unwrap(),
3300            serder7.said().unwrap()
3301        );
3302
3303        // sign serialization and verify signature
3304        let sig8 = match signers[4].sign(serder8.raw(), Some(0), None, None)? {
3305            Sigmat::Indexed(siger) => siger,
3306            _ => {
3307                return Err(KERIError::ValueError(
3308                    "Expected indexed signature".to_string(),
3309                ))
3310            }
3311        };
3312        assert!(signers[4].verfer().verify(sig8.raw(), serder8.raw())?);
3313
3314        // update key event verifier state - should fail with ValidationError
3315        let result = kever.update(
3316            &Locals::default(),
3317            serder8.clone(),
3318            vec![sig8.clone()],
3319            None,
3320            None,
3321            None,
3322            None,
3323            None,
3324            false,
3325            false,
3326            false,
3327        );
3328        assert!(result.is_err());
3329        assert!(matches!(result, Err(KERIError::ValidationError(_))));
3330
3331        // Event 8 Rotation (should also be rejected as identifier is non-transferable)
3332        let keys5 = vec![signers[5].verfer().qb64()];
3333        let nxt5 = vec![ndiger4.qb64()]; // reuse ndiger4 as in Python example
3334
3335        let serder8_rot = RotateEventBuilder::new(
3336            pre.clone(),
3337            keys5.clone(),
3338            serder7.said().unwrap().to_string(),
3339        )
3340        .with_sn(8)
3341        .with_ndigs(nxt5.clone())
3342        .build()?;
3343
3344        assert_eq!(serder8_rot.ked()["i"].as_str().unwrap(), pre);
3345        assert_eq!(serder8_rot.ked()["s"].as_str().unwrap(), "8");
3346        assert_eq!(
3347            serder8_rot.ked()["p"].as_str().unwrap(),
3348            serder7.said().unwrap()
3349        );
3350
3351        // sign serialization and verify signature
3352        let sig8_rot = match signers[4].sign(serder8_rot.raw(), Some(0), None, None)? {
3353            Sigmat::Indexed(siger) => siger,
3354            _ => {
3355                return Err(KERIError::ValueError(
3356                    "Expected indexed signature".to_string(),
3357                ))
3358            }
3359        };
3360        assert!(signers[4]
3361            .verfer()
3362            .verify(sig8_rot.raw(), serder8_rot.raw())?);
3363
3364        // update key event verifier state - should fail with ValidationError
3365        let result = kever.update(
3366            &Locals::default(),
3367            serder8_rot,
3368            vec![sig8_rot],
3369            None,
3370            None,
3371            None,
3372            None,
3373            None,
3374            false,
3375            false,
3376            false,
3377        );
3378        assert!(result.is_err());
3379        assert!(matches!(result, Err(KERIError::ValidationError(_))));
3380
3381        let mut db_digs = Vec::new();
3382        let val_iter = kever.db.kels.get_on_iter::<_, Vec<u8>>(&[&pre], 0)?;
3383
3384        for val_result in val_iter {
3385            let raw_bytes = val_result?;
3386            let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
3387            db_digs.push(string_val);
3388        }
3389
3390        assert_eq!(db_digs, event_digs);
3391
3392        Ok(())
3393    }
3394}