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#[derive(Debug, Clone, PartialEq)]
26pub struct LastEstLoc {
27 pub s: u64,
29 pub d: String,
31}
32
33pub struct Kever {
34 pub db: Arc<Baser>,
35 version: String, ilk: Ilk, pub delpre: Option<String>, pub(crate) delegated: bool, fner: Option<Number>, dater: Option<Dater>, 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 est_only: Option<bool>,
58 do_not_delegate: Option<bool>,
59}
60
61impl Kever {
62 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 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 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 return Self::reload(db, state);
115 }
116
117 let serder = serder.unwrap();
119 let sigers = sigers.unwrap();
120
121 let version = serder.version().clone();
123
124 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 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 };
159
160 kever.incept(serder.clone())?;
162
163 kever.config(serder.clone(), est_only)?;
165
166 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 kever.delpre = delpre;
183 kever.delegated = kever.delpre.is_some();
184
185 let wits = serder.backs().clone();
187
188 let (fn_num, dts) = kever.log_event(locals,
190 serder, sigers, wigers, wits, !check, delseqner, delsaider, firner, dater, local,
191 )?;
192
193 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 pub fn reload(db: Arc<Baser>, state: KeyStateRecord) -> Result<Self, KERIError> {
216 let prefixer = Prefixer::from_qb64(&state.i)
218 .map_err(|e| KERIError::ValueError(format!("Invalid identifier prefix: {}", e)))?;
219
220 let sner = Number::from_numh(&state.s)
222 .map_err(|e| KERIError::ValueError(format!("Invalid sequence number: {}", e)))?;
223
224 let fner = Number::from_numh(&state.f)
226 .map_err(|e| KERIError::ValueError(format!("Invalid first seen number: {}", e)))?;
227
228 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 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 let tholder = Tholder::new(
250 None,
251 None,
252 Some(TholderSith::from_sad_value(SadValue::String(state.kt))?),
253 )?;
254
255 let ntholder = Tholder::new(
257 None,
258 None,
259 Some(TholderSith::from_sad_value(SadValue::String(state.nt))?),
260 )?;
261
262 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 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 let toader = Number::from_numh(&state.bt)
282 .map_err(|e| KERIError::ValueError(format!("Invalid witness threshold: {}", e)))?;
283
284 let wits = state.b.clone();
286
287 let cuts = state.ee.br.clone().unwrap_or_default();
289 let adds = state.ee.ba.clone().unwrap_or_default();
290
291 let est_only = state.c.contains(&"EstOnly".to_string());
293 let do_not_delegate = state.c.contains(&"DoNotDelegate".to_string());
294
295 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 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 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 let serder = SerderKERI::from_raw(&raw, None)
331 .map_err(|e| KERIError::ValueError(format!("Invalid event serder: {}", e)))?;
332
333 Ok(Kever {
335 db,
336 version: format!("{}.{}", state.vn[0], state.vn[1]), 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 fn incept(&mut self, serder: SerderKERI) -> Result<(), KERIError> {
369 let ked = serder.sad();
371
372 let sner = serder.sner().ok_or_else(|| {
374 KERIError::ValidationError("Missing sequence number in inception event".to_string())
375 })?;
376
377 if sner.num() > 0 {
379 return Err(KERIError::ValidationError(format!(
380 "Nonzero sn={} in inception event.",
381 sner.num()
382 )));
383 }
384
385 let verfers = serder.verfers().ok_or_else(|| {
387 KERIError::ValidationError("Missing verifiers in inception event".to_string())
388 })?;
389
390 let tholder = serder.tholder().ok_or_else(|| {
392 KERIError::ValidationError("Missing threshold in inception event".to_string())
393 })?;
394
395 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 let prefixer = Prefixer::from_qb64(&serder.pre().unwrap())?;
407
408 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 let ndigers = serder.ndigers().unwrap_or_default();
419
420 let ntholder = serder.ntholder();
422
423 let cuts: Vec<String> = Vec::new();
425 let adds: Vec<String> = Vec::new();
426
427 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 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 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 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 let last_est = LastEstLoc {
496 s: sner.num() as u64,
497 d: serder.said().unwrap_or_default().to_string(),
498 };
499
500 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 fn config(&mut self, serder: SerderKERI, est_only: Option<bool>) -> Result<(), KERIError> {
528 const EST_ONLY: bool = false;
531 const DO_NOT_DELEGATE: bool = false;
532
533 self.est_only = match est_only {
536 Some(value) => Some(value),
537 None => Some(self.est_only.unwrap_or(EST_ONLY)),
538 };
539
540 self.do_not_delegate = Some(self.do_not_delegate.unwrap_or(DO_NOT_DELEGATE));
542
543 if let Some(traits) = serder.traits() {
545 if let Some(traits_array) = traits.as_array() {
547 for trait_value in traits_array {
549 if let Some(trait_str) = trait_value.as_str() {
550 match trait_str {
551 "EO" => self.est_only = Some(true),
553 "DND" => self.do_not_delegate = Some(true),
554 _ => (), }
556 }
557 }
558 }
559 }
560
561 Ok(())
562 }
563
564 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 let verfers = match verfers {
612 Some(v) => v,
613 None => return Err(KERIError::ValueError("Missing verfers".to_string())),
614 };
615
616 let toader = match toader {
618 Some(t) => t,
619 None => Number::from_num(&BigUint::from(0u32))?,
620 };
621
622 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 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 }
642 }
643
644 let (sigers, indices) = verify_sigs(&serder.raw(), sigers, &verfers)?;
646
647 if indices.is_empty() {
649 return Err(KERIError::ValidationError(format!(
650 "No verified signatures for evt = {:?}",
651 serder.ked()
652 )));
653 }
654
655 let delpre = if serder.ilk() == Some(Ilk::Dip) {
657 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 self.delpre.clone()
669 } else {
670 None
672 };
673
674 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 let werfers: Vec<Verfer> = wits
700 .iter()
701 .map(|wit| Verfer::from_qb64(wit))
702 .collect::<Result<Vec<Verfer>, _>>()?;
703
704 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 let pre = self.prefixer().unwrap().qb64();
715 if !tholder.satisfy(&indices) {
716 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 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 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 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 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 if self.escrow_pw_event(
797 &serder,
798 wigers.clone(),
799 sigers,
800 delseqner.as_ref(),
801 delsaider.as_ref(),
802 local,
803 )? {
804 }
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 if self.locally_delegated(locals, delpre.as_deref()) && !self.locally_owned(locals, None) {
821 if delseqner.is_none() || delsaider.is_none() {
822 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 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 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 pub fn locally_witnessed(&self, locals: &Locals, wits: Option<&[String]>, serder: Option<&SerderKERI>) -> bool {
902 let witnesses = match (wits, serder) {
904 (None, None) => self.wits(),
906
907 (Some(w), _) => w.to_vec(),
909
910 (None, Some(s)) => {
912 let prefixer = match self.prefixer() {
914 Some(p) => p,
915 None => return false, };
917
918 if s.pre() != Some(prefixer.qb64()) {
919 return false; }
921
922 match self.derive_backs(s) {
924 Ok((derived_wits, _, _)) => derived_wits,
925 Err(_) => return false, }
927 }
928 };
929
930 let local_prefix_set: HashSet<_> = locals.prefixes.iter().collect();
932 let witness_set: HashSet<_> = witnesses.iter().collect();
933
934 !local_prefix_set.is_disjoint(&witness_set)
936 }
937
938 pub fn derive_backs(
953 &self,
954 serder: &SerderKERI,
955 ) -> Result<(Vec<String>, Vec<String>, Vec<String>), KERIError> {
956 let ilk = serder.ilk().unwrap();
958 let sn = serder.sn().unwrap();
959
960 if (ilk != Ilk::Rot && ilk != Ilk::Drt)
963 || self.sner.as_ref().map_or(0, |n| n.num()) >= sn as u128
964 {
965 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 let wits = self.wits();
975 let wit_set: HashSet<String> = HashSet::from_iter(wits.iter().cloned());
976
977 let cuts = serder.cuts().unwrap_or_else(|| Vec::new());
979
980 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 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 let adds = serder.adds().unwrap_or_else(|| Vec::new());
1001
1002 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 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 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 let wit_set_after_cuts: HashSet<String> = wit_set.difference(&cut_set).cloned().collect();
1035
1036 let new_wit_set: HashSet<String> = wit_set_after_cuts.union(&add_set).cloned().collect();
1038
1039 let new_wits = new_wit_set.into_iter().collect::<Vec<String>>();
1041
1042 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 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 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 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
1133pub(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 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 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 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 fn exposeds(&self, sigers: &[Siger]) -> Result<Vec<usize>, KERIError> {
1234 let mut odxs = Vec::new();
1235
1236 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 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 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)); };
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)); }
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 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 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 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 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 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; let sner = serder.sn().unwrap_or_default(); let ilk = serder.ilk().unwrap();
1474
1475 if ilk == Ilk::Rot || ilk == Ilk::Drt {
1477 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 let (tholder, toader, wits, cuts, adds) = self.rotate(&serder)?;
1488
1489 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 let (fn_val, dts) = self.log_event(locals,
1507 serder.clone(),
1508 sigers_verified,
1509 wigers_verified,
1510 Some(wits.clone()),
1511 !check, delseqner_updated,
1513 delsaider_updated,
1514 firner,
1515 dater,
1516 local,
1517 )?;
1518
1519 self.sner = Some(Number::from_num(&BigUint::from(sner))?);
1521 self.serder = Some(serder.clone());
1522 self.ilk = ilk; 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 self.last_est = Some(LastEstLoc {
1534 s: sner,
1535 d: serder.said().unwrap().to_string(),
1536 });
1537
1538 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 if let Some(prefixer) = &self.prefixer {
1544 self.db.states.pin(&[&prefixer.qb64()], &self.state()?)?;
1545 }
1546 }
1547 }
1548 else if ilk == Ilk::Ixn {
1550 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 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 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 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 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, None, eager,
1607 local,
1608 )?;
1609
1610 let (fn_val, dts) = self.log_event(locals,
1612 serder.clone(),
1613 sigers_verified,
1614 wigers_verified,
1615 None, !check, None, None, None, None, local,
1622 )?;
1623
1624 self.sner = Some(Number::from_num(&BigUint::from(sner))?);
1626 self.serder = Some(serder);
1627 self.ilk = ilk;
1628
1629 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 if let Some(prefixer) = &self.prefixer {
1635 self.db.states.pin(&[&prefixer.qb64()], &self.state()?)?;
1636 }
1637 }
1638 }
1639 else {
1641 return Err(KERIError::ValidationError(format!(
1642 "Unsupported ilk = {} for evt = {:?}",
1643 ilk, ked
1644 )));
1645 }
1646
1647 Ok(())
1648 }
1649
1650 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 let self_sn = self.sner.as_ref().map(|n| n.num()).unwrap_or(0);
1679
1680 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 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 return Err(KERIError::ValidationError(format!(
1695 "Stale event sn = {} expecting = {} for evt = {:?}",
1696 sn,
1697 self_sn + 1,
1698 ked
1699 )));
1700 } else {
1701 if ilk == Ilk::Rot && self.ilk != Ilk::Ixn {
1703 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 let psn = sn - 1;
1712
1713 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 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 let pserder = SerderKERI::from_raw(&praw, None)
1742 .map_err(|e| KERIError::ValueError(format!("Invalid prior event: {}", e)))?;
1743
1744 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 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 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 let tholder = serder.tholder().unwrap_or_default();
1775 let keys = serder.keys().unwrap_or_default();
1776
1777 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 let (wits, cuts, adds) = self.derive_backs(serder)?;
1789
1790 let toader = serder.bner().unwrap_or_default();
1792
1793 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 let local = if local { true } else { false };
1833 let mut fn_num: Option<u64> = None; let dg_keys = vec![serder.pre().unwrap(), serder.said().unwrap().to_string()]; let now = chrono::Utc::now();
1840 let dts_b = now.to_rfc3339().into_bytes();
1841
1842 self.db.dtss.add(&dg_keys, &dts_b)?;
1844
1845 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 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 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 self.db.evts.put(&dg_keys, &serder.raw())?;
1876
1877 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 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 let _esr = match self.db.esrs.get(&dg_keys) {
1894 Ok(Some(mut esr)) => {
1895 if local && !esr.local {
1897 esr.local = local;
1898 self.db.esrs.pin(&dg_keys, &esr)?;
1899 }
1900 esr
1901 }
1902 _ => {
1903 let esr = EventSourceRecord::with_local(local);
1905 self.db.esrs.put(&dg_keys, &esr)?;
1906 esr
1907 }
1908 };
1909
1910 if first {
1912 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 let dts_to_set = match &dater {
1923 Some(d) => d.dtsb(),
1924 None => dts_b.clone(),
1925 };
1926
1927 self.db.dtss.pin(&dg_keys, &[&dts_to_set])?;
1929
1930 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 let sn_key = sn_key(serder.preb().unwrap(), serder.sn().unwrap());
1945 self.db.kels.add(&[sn_key], &serder.saidb().unwrap())?;
1946
1947 Ok((fn_num, now))
1949 }
1950
1951 pub fn state(&self) -> Result<KeyStateRecord, KERIError> {
1953 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 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 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 let keys: Vec<String> = verfers.iter().map(|verfer| verfer.qb64()).collect();
2015
2016 let ndigs = match &self.ndigers {
2018 Some(digers) => digers.iter().map(|diger| diger.qb64()).collect(),
2019 None => Vec::new(),
2020 };
2021
2022 let wits = self.wits().clone();
2024
2025 let pig = serder.prior().clone().unwrap_or_default();
2027
2028 let state_builder = StateEventBuilder::new(
2030 prefixer.qb64(), sner.num() as u64, pig, serder.said().unwrap().to_string(), fner.num() as u64, self.ilk.to_string(), keys, eevt, )
2039 .with_stamp(dater.dts()) .with_sith(tholder.sith()) .with_ndigs(ndigs) .with_toad(toader.num() as usize) .with_wits(wits) .with_cnfg(cnfg); let state_builder = match &self.ntholder {
2048 Some(ntholder) => state_builder.with_nsith(ntholder.sith()),
2049 None => state_builder,
2050 };
2051
2052 let state_builder = match &self.delpre {
2054 Some(delpre) => state_builder.with_dpre(delpre.clone()),
2055 None => state_builder,
2056 };
2057
2058 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 pub fn fetch_prior_digers(&self, sn: Option<u64>) -> Result<Option<Vec<Diger>>, KERIError> {
2124 let pre = match &self.prefixer {
2126 Some(prefixer) => prefixer.qb64(),
2127 None => return Err(KERIError::ValidationError("Missing prefixer".to_string())),
2128 };
2129
2130 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 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 let dgkey = dg_key(&pre, &digb?);
2154
2155 let raw = match self.db.evts.get::<_, Vec<u8>>(&[dgkey]) {
2157 Ok(evt) => evt,
2158 Err(_) => return Ok(None),
2159 };
2160
2161 let serder = SerderKERI::from_raw(&Vec::from(raw.unwrap()), None)?;
2163
2164 if serder.estive() {
2166 return Ok(serder.ndigers());
2168 }
2169 }
2170
2171 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
2187pub 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 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 pub fn with_locals(mut self, locals: Locals) -> Self {
2229 self.locals = locals;
2230 self
2231 }
2232
2233 pub fn with_state(mut self, state: KeyStateRecord) -> Self {
2235 self.state = Some(state);
2236 self
2237 }
2238
2239 pub fn with_serder(mut self, serder: SerderKERI) -> Self {
2241 self.serder = Some(serder);
2242 self
2243 }
2244
2245 pub fn with_sigers(mut self, sigers: Vec<Siger>) -> Self {
2247 self.sigers = Some(sigers);
2248 self
2249 }
2250
2251 pub fn with_wigers(mut self, wigers: Vec<Siger>) -> Self {
2253 self.wigers = Some(wigers);
2254 self
2255 }
2256
2257 pub fn with_est_only(mut self, est_only: bool) -> Self {
2259 self.est_only = Some(est_only);
2260 self
2261 }
2262
2263 pub fn with_delseqner(mut self, delseqner: Seqner) -> Self {
2265 self.delseqner = Some(delseqner);
2266 self
2267 }
2268
2269 pub fn with_delsaider(mut self, delsaider: Saider) -> Self {
2271 self.delsaider = Some(delsaider);
2272 self
2273 }
2274
2275 pub fn with_firner(mut self, firner: Seqner) -> Self {
2277 self.firner = Some(firner);
2278 self
2279 }
2280
2281 pub fn with_dater(mut self, dater: Dater) -> Self {
2283 self.dater = Some(dater);
2284 self
2285 }
2286
2287 pub fn with_eager(mut self, eager: bool) -> Self {
2289 self.eager = Some(eager);
2290 self
2291 }
2292
2293 pub fn with_local(mut self, local: bool) -> Self {
2295 self.local = Some(local);
2296 self
2297 }
2298
2299 pub fn with_check(mut self, check: bool) -> Self {
2301 self.check = Some(check);
2302 self
2303 }
2304
2305 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 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 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 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 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 let sn = 0; let toad = 0; let nsigs = 1; let mut saids = HashMap::new();
2392 saids.insert("i", pre_dex::ED25519.to_string());
2393
2394 let mut serder = SerderKERI::new(
2395 None, None, Some(true), None, None, None, None, Some(Ilk::Icp), Some(saids), )?;
2405
2406 let mut sad = serder.sad();
2408
2409 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 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 )?; 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 let tser0 = serder.clone();
2467
2468 let tsig0 = skp0.sign(tser0.raw(), Some(0), None, None)?;
2470
2471 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 assert!(skp0.verfer().verify(tsig0.raw(), tser0.raw())?);
2483
2484 let kever = KeverBuilder::new(Arc::new(db))
2486 .with_serder(tser0.clone())
2487 .with_sigers(vec![tsig0])
2488 .build()?;
2489
2490 assert_eq!(kever.prefixer().unwrap().qb64(), aid0);
2492
2493 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 let state: KeyStateRecord = kever
2512 .db
2513 .states
2514 .get(&[&prefixer.qb64()])
2515 .expect("State not found")
2516 .unwrap();
2517
2518 let sner = kever
2520 .sner
2521 .as_ref()
2522 .ok_or_else(|| KERIError::ValueError("Missing sner in Kever".to_string()))?;
2523
2524 let sner_hex = format!("{:x}", sner.num());
2526
2527 assert_eq!(state.s, sner_hex);
2529 assert_eq!(state.s, "0"); let serder = kever
2533 .serder
2534 .as_ref()
2535 .ok_or_else(|| KERIError::ValueError("Missing serder in Kever".to_string()))?;
2536
2537 let feqner: Number = kever
2539 .db
2540 .fons
2541 .get(&[&prefixer.qb64(), &serder.said().unwrap().to_string()])?
2542 .unwrap();
2543
2544 assert_eq!(feqner.num(), kever.sner.as_ref().unwrap().num());
2546
2547 let ksr = kever.state()?;
2549
2550 assert_eq!(ksr, state);
2552
2553 assert_eq!(ksr.i, prefixer.qb64());
2555
2556 assert_eq!(ksr.s, sner_hex);
2558
2559 let verfers = kever
2561 .verfers
2562 .as_ref()
2563 .ok_or_else(|| KERIError::ValueError("Missing verfers in Kever".to_string()))?;
2564
2565 let state_keys = ksr.k;
2567
2568 let verfer_keys: Vec<String> = verfers.iter().map(|verfer| verfer.qb64()).collect();
2570
2571 assert_eq!(state_keys, verfer_keys);
2573 Ok(())
2574 }
2575
2576 #[test]
2577 fn test_kever_missing_args() -> Result<(), KERIError> {
2578 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 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 let pubkeys: Vec<String> = signers.iter().map(|s| s.verfer().qb64()).collect();
2612
2613 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 let mut event_digs = Vec::new();
2637
2638 let keys0 = vec![signers[0].verfer().qb64()];
2640
2641 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 assert_eq!(
2648 nxt1,
2649 vec!["EIQsSW4KMrLzY1HQI9H_XxY6MyzhaFFXhG6fdBb5Wxta".to_string()]
2650 );
2651
2652 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 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 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 assert!(signers[0].verfer().verify(sig0.raw(), serder0.raw())?);
2699
2700 let mut kever = KeverBuilder::new(Arc::new(db))
2702 .with_serder(serder0.clone())
2703 .with_sigers(vec![sig0])
2704 .build()?;
2705
2706 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 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 assert_eq!(kever.ndigs().clone(), nxt1);
2731
2732 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); 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 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 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 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 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); 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 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 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 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 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); 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 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 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 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 assert_eq!(kever.ndigs().clone(), nxt4);
3212
3213 let serder7 = RotateEventBuilder::new(
3215 pre.clone(),
3216 keys4.clone(),
3217 serder6.said().unwrap().to_string(),
3218 )
3219 .with_sn(7)
3220 .build()?; 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 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 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 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 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 assert_eq!(kever.ndigs().len(), 0);
3287
3288 assert!(!kever.transferable());
3290
3291 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 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 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 let keys5 = vec![signers[5].verfer().qb64()];
3333 let nxt5 = vec![ndiger4.qb64()]; 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 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 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}