1use std::collections::HashMap;
16use std::sync::Arc;
17
18use indexmap::{IndexMap, IndexSet};
19use tracing::debug;
20
21use crate::cesr::cigar::Cigar;
22use crate::cesr::diger::Diger;
23use crate::cesr::indexing::siger::Siger;
24use crate::cesr::indexing::Indexer;
25use crate::cesr::verfer::Verfer;
26use crate::cesr::tholder::{Tholder, TholderSith};
27use crate::cesr::Matter;
28use crate::cesr::Tiers;
29use crate::keri::app::configing::Configer;
30use crate::keri::app::habbing::Hab;
31use crate::keri::app::keeping::creators::Algos;
32use crate::keri::app::keeping::{Keeper, Manager};
33use crate::keri::core::eventing::kever::Kever;
34use crate::keri::core::eventing::kevery::Kevery;
35use crate::keri::core::parsing::{Message, Parser};
36use crate::keri::core::routing::Revery;
37use crate::keri::core::serdering::{SadValue, Serder, SerderKERI};
38use crate::keri::db::basing::Baser;
39use crate::keri::db::dbing::LMDBer;
40use crate::keri::KERIError;
41
42#[derive(Default)]
44pub struct HaberyOptions {
45 pub base: Option<String>,
47 pub head_dir: Option<std::path::PathBuf>,
49 pub temp: bool,
51 pub salt: Option<String>,
53 pub cf: Option<Arc<Configer>>,
55 pub lax: bool,
57}
58
59#[derive(Default)]
62pub struct MakeHabArgs {
63 pub transferable: Option<bool>,
64 pub isith: Option<Tholder>,
65 pub icount: Option<usize>,
66 pub nsith: Option<Tholder>,
67 pub ncount: Option<usize>,
68 pub toad: Option<u32>,
69 pub wits: Option<Vec<String>>,
70 pub delpre: Option<String>,
71 pub est_only: Option<bool>,
72 pub d_n_d: Option<bool>,
73 pub data: Option<Vec<SadValue>>,
75 pub algo: Option<Algos>,
76 pub salt: Option<Vec<u8>>,
77 pub tier: Option<Tiers>,
78}
79
80#[derive(Debug, Clone)]
82struct HabState {
83 name: String,
84 ns: Option<String>,
85 pre: String,
86 group: Option<GroupMembers>,
88}
89
90#[derive(Debug, Clone, PartialEq, Eq)]
92pub struct GroupMembers {
93 pub mid: String,
95 pub smids: Vec<String>,
97 pub rmids: Vec<String>,
99}
100
101pub struct Habery {
102 name: String,
103 temp: bool,
104 db: Arc<Baser>,
105 mgr: Manager,
106 kvy: Kevery,
107 rvy: Revery,
108 psr: Parser<std::io::Empty>,
109 cf: Option<Arc<Configer>>,
110 habs: IndexMap<String, HabState>,
112}
113
114impl Habery {
115 pub fn open(name: &str, opts: HaberyOptions) -> Result<Self, KERIError> {
118 crate::init().map_err(|e| KERIError::ConfigurationError(e.to_string()))?;
119
120 let mut builder = LMDBer::builder()
121 .name(name)
122 .base(opts.base.clone().unwrap_or_default())
123 .temp(opts.temp)
124 .reopen(true);
125 if let Some(head_dir) = &opts.head_dir {
126 builder = builder.head_dir(head_dir.clone());
127 }
128 let lmdber = Arc::new(
129 builder
130 .build()
131 .map_err(|e| KERIError::DatabaseError(format!("open {}: {}", name, e)))?,
132 );
133
134 let ks = Keeper::new(lmdber.clone())
135 .map_err(|e| KERIError::DatabaseError(format!("keeper: {}", e)))?;
136 let db = Arc::new(
137 Baser::new(lmdber.clone())
138 .map_err(|e| KERIError::DatabaseError(format!("baser: {}", e)))?,
139 );
140 let mgr = Manager::new(
141 ks,
142 None,
143 None,
144 None,
145 None,
146 opts.salt.map(String::into_bytes),
147 None,
148 )?;
149 let kvy = Kevery::new(
150 None,
151 db.clone(),
152 None,
153 Some(opts.lax),
154 Some(true), None,
156 None,
157 None,
158 )?;
159 let rvy = Revery::new(db.clone(), None, None, Some(opts.lax), Some(true));
160 let psr = Parser::without_handlers(std::io::empty(), true, false, false);
161
162 let mut hby = Habery {
163 name: name.to_string(),
164 temp: opts.temp,
165 db,
166 mgr,
167 kvy,
168 rvy,
169 psr,
170 cf: opts.cf,
171 habs: IndexMap::new(),
172 };
173 hby.reload()?;
174 Ok(hby)
175 }
176
177 pub fn reload(&mut self) -> Result<(), KERIError> {
179 let empty: &[&[u8]] = &[];
180
181 self.kvy.kevers.clear();
182 for (_keys, state) in self
183 .db
184 .states
185 .get_item_iter(empty)
186 .map_err(|e| KERIError::DatabaseError(format!("states: {}", e)))?
187 {
188 let pre = state.i.clone();
189 let kever = Kever::reload(self.db.clone(), state)?;
190 self.kvy.kevers.insert(pre, kever);
191 }
192
193 self.kvy.locals.prefixes.clear();
194 self.kvy.locals.groups.clear();
195 self.habs.clear();
196 for (_keys, habord) in self
197 .db
198 .habs
199 .get_item_iter(empty)
200 .map_err(|e| KERIError::DatabaseError(format!("habs: {}", e)))?
201 {
202 let pre = habord.hid.clone();
203 if !self.kvy.kevers.contains_key(&pre) && habord.mid.is_none() {
204 return Err(KERIError::ConfigurationError(format!(
205 "Problem loading Hab pre={} name={:?}: no key state",
206 pre, habord.name
207 )));
208 }
209 self.kvy.locals.prefixes.insert(pre.clone());
210 if habord.mid.is_some() && habord.sid.is_none() {
211 self.kvy.locals.groups.insert(pre.clone());
212 }
213 self.habs.insert(
214 pre.clone(),
215 HabState {
216 name: habord.name.clone().unwrap_or_default(),
217 ns: habord.domain.clone(),
218 pre,
219 group: habord.mid.clone().map(|mid| {
220 let smids = habord.smids.clone().unwrap_or_default();
221 GroupMembers {
222 mid,
223 rmids: habord.rmids.clone().unwrap_or_else(|| smids.clone()),
224 smids,
225 }
226 }),
227 },
228 );
229 }
230 debug!(
231 "Habery {} loaded {} habs, {} kevers",
232 self.name,
233 self.habs.len(),
234 self.kvy.kevers.len()
235 );
236 Ok(())
237 }
238
239 pub fn make_hab(&mut self, name: &str, args: MakeHabArgs) -> Result<Hab<'_>, KERIError> {
241 self.make_hab_ns(name, None, args)
242 }
243
244 pub fn make_hab_ns(
246 &mut self,
247 name: &str,
248 ns: Option<&str>,
249 args: MakeHabArgs,
250 ) -> Result<Hab<'_>, KERIError> {
251 let ns = ns.map(str::to_string);
252 self.check_name_free(name, ns.as_deref())?;
253
254 let mut hab = Hab::new(
255 self.db.clone(),
256 &mut self.mgr,
257 None,
258 &mut self.rvy,
259 &mut self.kvy,
260 &mut self.psr,
261 self.cf.clone(),
262 name.to_string(),
263 ns.clone(),
264 None,
265 self.temp,
266 None,
267 )?;
268 hab.make(
269 None,
270 None,
271 None,
272 None,
273 None,
274 args.transferable,
275 args.isith,
276 args.icount,
277 args.nsith,
278 args.ncount,
279 args.toad,
280 args.wits,
281 args.delpre,
282 args.est_only,
283 args.d_n_d,
284 None,
285 args.data,
286 args.algo,
287 args.salt,
288 args.tier,
289 )?;
290 let pre = hab
291 .pre
292 .clone()
293 .ok_or_else(|| KERIError::ValueError("make produced no prefix".to_string()))?;
294 drop(hab);
295
296 self.habs.insert(
297 pre.clone(),
298 HabState {
299 name: name.to_string(),
300 ns,
301 pre: pre.clone(),
302 group: None,
303 },
304 );
305 self.hab_by_pre(&pre)
306 }
307
308 pub fn hab_by_pre(&mut self, pre: &str) -> Result<Hab<'_>, KERIError> {
310 let state = self
311 .habs
312 .get(pre)
313 .cloned()
314 .ok_or_else(|| KERIError::MissingEntryError(format!("No local Hab {}", pre)))?;
315 self.view(state)
316 }
317
318 pub fn hab_by_name(&mut self, name: &str) -> Result<Hab<'_>, KERIError> {
320 let state = self
321 .habs
322 .values()
323 .find(|h| h.name == name && h.ns.is_none())
324 .cloned()
325 .ok_or_else(|| KERIError::MissingEntryError(format!("No local Hab named {}", name)))?;
326 self.view(state)
327 }
328
329 fn view(&mut self, state: HabState) -> Result<Hab<'_>, KERIError> {
330 let delpre = self
331 .kvy
332 .kevers
333 .get(&state.pre)
334 .and_then(|k| k.delpre());
335 let mut hab = Hab::new(
336 self.db.clone(),
337 &mut self.mgr,
338 None,
339 &mut self.rvy,
340 &mut self.kvy,
341 &mut self.psr,
342 self.cf.clone(),
343 state.name,
344 state.ns,
345 Some(state.pre),
346 self.temp,
347 delpre,
348 )?;
349 hab.inited = true;
350 Ok(hab)
351 }
352
353 pub fn ingest(&mut self, ims: &[u8], local: bool) -> Result<usize, KERIError> {
363 let msgs = self.psr.parse_messages(ims)?;
364 let n = msgs.len();
365 let mut result = Ok(n);
366 for msg in msgs {
367 match route_message(&mut self.kvy, &mut self.rvy, msg, local) {
368 Ok(())
371 | Err(KERIError::OutOfOrderError(_))
372 | Err(KERIError::LikelyDuplicitousError(_))
373 | Err(KERIError::MissingSignatureError(_))
374 | Err(KERIError::MissingWitnessSignatureError(_))
375 | Err(KERIError::MisfitEventSourceError(_))
376 | Err(KERIError::MissingDelegableApprovalError(_))
377 | Err(KERIError::MissingDelegationError(_))
378 | Err(KERIError::UnverifiedReceiptError(_))
379 | Err(KERIError::UnverifiedWitnessReceiptError(_)) => {}
380 Err(e) => {
381 result = Err(e);
382 break;
383 }
384 }
385 }
386 self.process_escrows();
387 result
388 }
389
390 pub fn process_escrows(&mut self) {
393 self.kvy.process_escrows();
394 }
395
396 pub fn habs(&self) -> impl Iterator<Item = (&str, &str)> {
398 self.habs.values().map(|h| (h.name.as_str(), h.pre.as_str()))
399 }
400
401 pub fn name(&self) -> &str {
402 &self.name
403 }
404
405 pub fn path(&self) -> Option<std::path::PathBuf> {
407 self.db.path()
408 }
409
410 pub fn db(&self) -> &Arc<Baser> {
411 &self.db
412 }
413
414 pub fn kevers(&self) -> &HashMap<String, Kever> {
416 &self.kvy.kevers
417 }
418
419 pub fn prefixes(&self) -> &IndexSet<String> {
421 &self.kvy.locals.prefixes
422 }
423
424 pub fn kevery(&self) -> &Kevery {
425 &self.kvy
426 }
427
428 pub fn kevery_mut(&mut self) -> &mut Kevery {
429 &mut self.kvy
430 }
431
432 fn check_name_free(&self, name: &str, ns: Option<&str>) -> Result<(), KERIError> {
433 if self
434 .habs
435 .values()
436 .any(|h| h.name == name && h.ns.as_deref() == ns)
437 {
438 return Err(KERIError::ValueError(format!(
439 "A Hab named {} already exists",
440 name
441 )));
442 }
443 Ok(())
444 }
445
446 fn local_pre(&self, name: &str) -> Result<String, KERIError> {
447 self.habs
448 .values()
449 .find(|h| h.name == name && h.ns.is_none())
450 .map(|h| h.pre.clone())
451 .ok_or_else(|| KERIError::MissingEntryError(format!("No local Hab named {}", name)))
452 }
453}
454
455impl Habery {
458 pub fn group_members(&self, pre: &str) -> Option<&GroupMembers> {
460 self.habs.get(pre).and_then(|h| h.group.as_ref())
461 }
462
463 pub fn extract_merfers_migers(
467 &self,
468 smids: &[String],
469 rmids: Option<&[String]>,
470 ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
471 let rmids = rmids.unwrap_or(smids);
472 let kever = |mid: &String| {
473 self.kvy.kevers.get(mid).ok_or_else(|| {
474 KERIError::ConfigurationError(format!("KEL missing for group member {}", mid))
475 })
476 };
477 let mut merfers = Vec::with_capacity(smids.len());
478 for mid in smids {
479 let verfers = kever(mid)?.verfers.clone().unwrap_or_default();
480 if verfers.len() != 1 {
481 return Err(KERIError::ConfigurationError(format!(
482 "Group member {} must have exactly one key, has {}",
483 mid,
484 verfers.len()
485 )));
486 }
487 merfers.extend(verfers);
488 }
489 let mut migers = Vec::with_capacity(rmids.len());
490 for mid in rmids {
491 let digers = kever(mid)?.ndigers.clone().unwrap_or_default();
492 if digers.len() > 1 {
493 return Err(KERIError::ConfigurationError(format!(
494 "Group member {} must have at most one next key digest, has {}",
495 mid,
496 digers.len()
497 )));
498 }
499 migers.extend(digers); }
501 Ok((merfers, migers))
502 }
503
504 pub fn join_group_hab(
507 &mut self,
508 pre: &str,
509 group: &str,
510 mhab_name: &str,
511 smids: &[String],
512 rmids: Option<&[String]>,
513 ) -> Result<Hab<'_>, KERIError> {
514 let members = self.check_group(group, mhab_name, smids, rmids)?;
515 self.save_group(pre, group, members)?;
516 self.hab_by_pre(pre)
517 }
518
519 pub fn join_group_inception(
529 &mut self,
530 group: &str,
531 mhab_name: &str,
532 smids: &[String],
533 rmids: Option<&[String]>,
534 proposal: &[u8],
535 ) -> Result<Vec<u8>, KERIError> {
536 let members = self.check_group(group, mhab_name, smids, rmids)?;
537
538 let mut msgs = self.psr.parse_messages(proposal)?;
539 if msgs.len() != 1 {
540 return Err(KERIError::ValidationError(format!(
541 "expected one group inception, got {} messages",
542 msgs.len()
543 )));
544 }
545 let (serder, mut sigers) = match msgs.pop() {
546 Some(Message::KeyEvent { serder, sigers, .. }) => (*serder, sigers.unwrap_or_default()),
547 _ => {
548 return Err(KERIError::ValidationError(
549 "proposal is not a key event".to_string(),
550 ))
551 }
552 };
553 if serder.ilk() != Some(crate::keri::Ilk::Icp) {
554 return Err(KERIError::ValidationError(format!(
555 "proposal is a {:?} event, not an icp",
556 serder.ilk()
557 )));
558 }
559 if !serder.backs().unwrap_or_default().is_empty() {
560 return Err(KERIError::ValidationError(
561 "witnessed group inceptions are not supported yet".to_string(),
562 ));
563 }
564 let pre = serder
565 .pre()
566 .ok_or_else(|| KERIError::ValidationError("proposal has no prefix".to_string()))?;
567
568 let (merfers, migers) = self.extract_merfers_migers(&members.smids, Some(&members.rmids))?;
570 let keys: Vec<String> = serder.verfers().unwrap_or_default().iter().map(|v| v.qb64()).collect();
571 let ndigs = serder.ndigs().unwrap_or_default();
572 let want_keys: Vec<String> = merfers.iter().map(|v| v.qb64()).collect();
573 let want_ndigs: Vec<String> = migers.iter().map(|d| d.qb64()).collect();
574 if keys != want_keys {
575 return Err(KERIError::ValidationError(format!(
576 "proposal keys {:?} do not match members' current keys {:?}",
577 keys, want_keys
578 )));
579 }
580 if ndigs != want_ndigs {
581 return Err(KERIError::ValidationError(format!(
582 "proposal next digests {:?} do not match members' next digests {:?}",
583 ndigs, want_ndigs
584 )));
585 }
586
587 self.save_group(&pre, group, members.clone())?;
589 let result = (|| {
590 let own = self.sign_as_member(&members.mid, serder.raw(), &merfers)?;
591 for siger in own {
592 if !sigers.iter().any(|s| s.index() == siger.index()) {
593 sigers.push(siger);
594 }
595 }
596 self.process_own_group_event(&serder, &sigers)?;
597 crate::keri::core::eventing::messagize(&serder, Some(&sigers), None, None, None, false)
598 .map_err(|e| KERIError::ValueError(format!("messagize: {}", e)))
599 })();
600 if result.is_err() {
601 self.forget_group(&pre, group);
602 }
603 result
604 }
605
606 pub fn make_group_hab(
618 &mut self,
619 group: &str,
620 mhab_name: &str,
621 smids: &[String],
622 rmids: Option<&[String]>,
623 isith: Option<TholderSith>,
624 nsith: Option<TholderSith>,
625 ) -> Result<Vec<u8>, KERIError> {
626 let members = self.check_group(group, mhab_name, smids, rmids)?;
627 let (merfers, migers) = self.extract_merfers_migers(&members.smids, Some(&members.rmids))?;
628 let isith = isith.unwrap_or_else(|| {
629 TholderSith::HexString(format!("{:x}", std::cmp::max(1, merfers.len().div_ceil(2))))
630 });
631 let nsith = nsith.unwrap_or_else(|| isith.clone());
632 let serder = crate::keri::core::eventing::incept::InceptionEventBuilder::new(
633 merfers.iter().map(|v| v.qb64()).collect(),
634 )
635 .with_ndigs(migers.iter().map(|d| d.qb64()).collect())
636 .with_isith(isith)
637 .with_nsith(nsith)
638 .with_code(crate::cesr::mtr_dex::BLAKE3_256.to_string())
639 .build()?;
640 let pre = serder
641 .pre()
642 .ok_or_else(|| KERIError::ValueError("group inception has no prefix".to_string()))?;
643
644 self.save_group(&pre, group, members.clone())?;
645 let result = (|| {
646 let sigers = self.sign_as_member(&members.mid, serder.raw(), &merfers)?;
647 self.process_own_group_event(&serder, &sigers)?;
648 crate::keri::core::eventing::messagize(&serder, Some(&sigers), None, None, None, false)
649 .map_err(|e| KERIError::ValueError(format!("messagize: {}", e)))
650 })();
651 if result.is_err() {
652 self.forget_group(&pre, group);
653 }
654 result
655 }
656
657 fn process_own_group_event(&mut self, serder: &SerderKERI, sigers: &[Siger]) -> Result<(), KERIError> {
660 match self.kvy.process_event(
661 serder.clone(),
662 sigers.to_vec(),
663 None,
664 None,
665 None,
666 None,
667 None,
668 None,
669 Some(true),
670 ) {
671 Ok(()) | Err(KERIError::MissingSignatureError(_)) => Ok(()),
672 Err(e) => Err(e),
673 }
674 }
675
676 pub fn sign_as_member(
680 &mut self,
681 mid: &str,
682 ser: &[u8],
683 verfers: &[Verfer],
684 ) -> Result<Vec<Siger>, KERIError> {
685 let mverfer = self
686 .kvy
687 .kevers
688 .get(mid)
689 .and_then(|k| k.verfers.clone())
690 .and_then(|v| v.into_iter().next())
691 .ok_or_else(|| KERIError::MissingEntryError(format!("no key state for {}", mid)))?;
692 let csi = verfers
693 .iter()
694 .position(|v| v.qb64() == mverfer.qb64())
695 .ok_or_else(|| {
696 KERIError::ValueError(format!("member {} has no key in this group event", mid))
697 })? as u32;
698 let hab = self.hab_by_pre(mid)?;
699 hab.sign(ser, Some(vec![mverfer]), Some(true), Some(vec![csi]), Some(vec![None]), None)
702 }
703
704 pub fn complete_delegation(&mut self, pre: &str, sn: u64) -> Result<Option<Vec<u8>>, KERIError> {
719 if !self.habs.contains_key(pre) {
720 return Err(KERIError::ValueError(format!("{} is not a local identifier", pre)));
721 }
722 let delpre = self
723 .kvy
724 .kevers
725 .get(pre)
726 .ok_or_else(|| KERIError::MissingEntryError(format!("no key state for {}", pre)))?
727 .delpre()
728 .ok_or_else(|| KERIError::ValueError(format!("{} is not delegated", pre)))?;
729 let said = self
730 .db
731 .get_ke_last(crate::keri::db::dbing::keys::sn_key(pre, sn))?
732 .ok_or_else(|| KERIError::MissingEntryError(format!("no event for {} at sn {}", pre, sn)))?;
733 let Some(dkever) = self.kvy.kevers.get(&delpre) else {
734 return Ok(None); };
736 let toad = dkever.toader().map(|t| t.num() as usize).unwrap_or(0);
737 let seal = crate::keri::core::eventing::SealEvent::new(
738 pre.to_string(),
739 format!("{:x}", sn),
740 said.clone(),
741 );
742 let Some(dserder) = self.db.fetch_last_sealing_event_by_event_seal(&delpre, &seal, 0, toad)? else {
743 return Ok(None);
744 };
745 let dsn = dserder
746 .sn()
747 .ok_or_else(|| KERIError::ValueError("delegating event has no sn".to_string()))?;
748 let dsaid = dserder
749 .said()
750 .ok_or_else(|| KERIError::ValueError("delegating event has no SAID".to_string()))?;
751 let couple = [
752 crate::cesr::seqner::Seqner::from_sn(dsn as u128).qb64(),
753 dsaid.to_string(),
754 ]
755 .concat();
756 self.db
757 .aess
758 .pin(&[&crate::keri::db::dbing::keys::dg_key(pre, &said)], &couple.as_bytes().to_vec())
759 .map_err(|e| KERIError::DatabaseError(format!("aess: {}", e)))?;
760 self.db.clone_evt_msg_at(pre, sn).map(Some)
761 }
762
763 pub fn pending_delegations(&self) -> Result<Vec<(String, u64, String)>, KERIError> {
768 let mut out = Vec::new();
769 for index in [&self.db.delegables, &self.db.misfits] {
770 let items = index
771 .get_item_iter(&[b"".as_slice()], false)
772 .map_err(|e| KERIError::DatabaseError(format!("escrow index: {}", e)))?;
773 for (keys, said) in items {
774 let key = keys
775 .iter()
776 .map(|k| String::from_utf8_lossy(k).to_string())
777 .collect::<Vec<_>>()
778 .join(".");
779 let Some((pre, snh)) = key.rsplit_once('.') else { continue };
780 let Ok(sn) = u64::from_str_radix(snh, 16) else { continue };
781 let said = String::from_utf8_lossy(&said).to_string();
782 let Some(raw) = self.db.get_evt(crate::keri::db::dbing::keys::dg_key(pre, &said))? else { continue };
783 let serder = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(&raw, None)?;
784 let delpre = match serder.ilk() {
785 Some(crate::keri::Ilk::Dip) => serder.delpre(),
786 Some(crate::keri::Ilk::Drt) => self.kvy.kevers.get(pre).and_then(|k| k.delpre()),
787 _ => None,
788 };
789 let local_delegator = delpre.map_or(false, |d| self.habs.contains_key(&d));
790 let already = self.db.get_ke_last(crate::keri::db::dbing::keys::sn_key(pre, sn))?.as_deref() == Some(said.as_str());
791 if local_delegator && !already && !out.iter().any(|(_, _, s): &(String, u64, String)| s == &said) {
792 out.push((pre.to_string(), sn, said));
793 }
794 }
795 }
796 Ok(out)
797 }
798
799 pub fn approve_delegation(
806 &mut self,
807 delegator_alias: &str,
808 delegate: &str,
809 sn: u64,
810 rotate: bool,
811 ) -> Result<Vec<u8>, KERIError> {
812 use crate::keri::db::dbing::keys::{dg_key, sn_key};
813 let (_, _, said) = self
814 .pending_delegations()?
815 .into_iter()
816 .find(|(p, s, _)| p == delegate && *s == sn)
817 .ok_or_else(|| {
818 KERIError::MissingEntryError(format!("no delegated event of {} at sn {} awaits approval", delegate, sn))
819 })?;
820 let raw = self
821 .db
822 .get_evt(dg_key(delegate, &said))?
823 .ok_or_else(|| KERIError::MissingEntryError(format!("missing escrowed event {}", said)))?;
824 let serder = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(&raw, None)?;
825 let dg = [delegate, said.as_str()];
826 let sigers = crate::keri::core::eventing::kevery::load_sigers(
827 self.db.sigs.get(&dg).map_err(|e| KERIError::DatabaseError(format!("sigs: {}", e)))?,
828 )?;
829 let wigers = crate::keri::core::eventing::kevery::load_sigers(
830 self.db.wigs.get(&dg).map_err(|e| KERIError::DatabaseError(format!("wigs: {}", e)))?,
831 )?;
832
833 let seal: SadValue = serde_json::from_str(&format!(
834 r#"{{"i":"{}","s":"{:x}","d":"{}"}}"#,
835 delegate, sn, said
836 ))
837 .map_err(|e| KERIError::ValueError(format!("seal: {}", e)))?;
838 let anchor = {
839 let mut hab = self.hab_by_name(delegator_alias)?;
840 if rotate {
841 hab.rotate(None, None, None, None, None, None, Some(vec![seal]))?
842 } else {
843 hab.interact(Some(vec![seal]))?
844 }
845 };
846 let aserder = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(&anchor, None)?;
847 let seqner = crate::cesr::seqner::Seqner::from_sn(aserder.sn().unwrap_or_default() as u128);
848 let saider = crate::cesr::saider::Saider::from_qb64(&aserder.said().unwrap_or_default())
849 .map_err(|e| KERIError::ValueError(format!("saider: {}", e)))?;
850
851 self.kvy.process_event(
852 serder,
853 sigers,
854 if wigers.is_empty() { None } else { Some(wigers) },
855 Some(seqner),
856 Some(saider),
857 None,
858 None,
859 None,
860 Some(true),
861 )?;
862 for index in [&self.db.delegables, &self.db.misfits] {
863 let _ = index.rem(&[sn_key(delegate, sn)], Some(&said.as_bytes().to_vec()));
864 }
865 Ok(anchor)
866 }
867
868 fn check_group(
869 &self,
870 group: &str,
871 mhab_name: &str,
872 smids: &[String],
873 rmids: Option<&[String]>,
874 ) -> Result<GroupMembers, KERIError> {
875 self.check_name_free(group, None)?;
876 let mid = self.local_pre(mhab_name)?;
877 let rmids = rmids.map(<[String]>::to_vec).unwrap_or_else(|| smids.to_vec());
878 if !smids.contains(&mid) && !rmids.contains(&mid) {
879 return Err(KERIError::ConfigurationError(format!(
880 "Local member {} must be in smids {:?} and/or rmids {:?}",
881 mid, smids, rmids
882 )));
883 }
884 for m in smids.iter().chain(rmids.iter()) {
885 if !self.kvy.kevers.contains_key(m) {
886 return Err(KERIError::ConfigurationError(format!(
887 "KEL missing for group member {}",
888 m
889 )));
890 }
891 }
892 Ok(GroupMembers {
893 mid,
894 smids: smids.to_vec(),
895 rmids,
896 })
897 }
898
899 fn save_group(&mut self, pre: &str, group: &str, members: GroupMembers) -> Result<(), KERIError> {
900 let habord = crate::keri::db::basing::HabitatRecord {
901 hid: pre.to_string(),
902 name: Some(group.to_string()),
903 mid: Some(members.mid.clone()),
904 smids: Some(members.smids.clone()),
905 rmids: Some(members.rmids.clone()),
906 ..Default::default()
907 };
908 self.db
909 .habs
910 .pin(&[pre.as_bytes()], &habord)
911 .map_err(|e| KERIError::DatabaseError(format!("habs: {}", e)))?;
912 self.db
913 .names
914 .pin(&["".as_bytes(), group.as_bytes()], &pre.as_bytes())
915 .map_err(|e| KERIError::DatabaseError(format!("names: {}", e)))?;
916 self.kvy.locals.prefixes.insert(pre.to_string());
917 self.kvy.locals.groups.insert(pre.to_string());
918 self.habs.insert(
919 pre.to_string(),
920 HabState {
921 name: group.to_string(),
922 ns: None,
923 pre: pre.to_string(),
924 group: Some(members),
925 },
926 );
927 Ok(())
928 }
929
930 fn forget_group(&mut self, pre: &str, group: &str) {
931 let _ = self.db.habs.rem(&[pre.as_bytes()]);
932 let _ = self.db.names.rem(&["".as_bytes(), group.as_bytes()]);
933 self.kvy.locals.prefixes.shift_remove(pre);
934 self.kvy.locals.groups.shift_remove(pre);
935 self.habs.shift_remove(pre);
936 }
937}
938
939pub fn route_message(
942 kvy: &mut Kevery,
943 _rvy: &mut Revery,
944 msg: Message,
945 local: bool,
946) -> Result<(), KERIError> {
947 match msg {
948 Message::KeyEvent {
949 serder,
950 sigers,
951 wigers,
952 delseqner,
953 delsaider,
954 firner,
955 dater,
956 ..
957 } => kvy.process_event(
958 *serder,
959 sigers.unwrap_or_default(),
960 wigers,
961 delseqner,
962 delsaider,
963 firner,
964 dater,
965 None,
966 Some(local),
967 ),
968 Message::Receipt { serder, cigars, .. } => {
969 kvy.process_receipt(*serder, cigars, Some(local))
970 }
971 Message::WitnessReceipt { serder, wigers, .. } => {
972 kvy.process_receipt_witness(*serder, wigers, Some(local))
973 }
974 Message::Query {
975 serder,
976 source,
977 sigers,
978 cigar,
979 } => kvy.process_query(*serder, source, sigers, cigar),
980 Message::ReplyNonTrans { serder, cigars } => {
981 let db = kvy.db.clone();
982 process_reply_nontrans(&db, serder.raw(), &cigars)
983 }
984 Message::ReplyTrans { .. } => {
985 debug!("replies signed by transferable AIDs not yet handled");
986 Ok(())
987 }
988 other => {
989 debug!("message type not yet handled: {:?}", std::mem::discriminant(&other));
990 Ok(())
991 }
992 }
993}
994
995fn process_reply_nontrans(db: &Baser, raw: &[u8], cigars: &[Cigar]) -> Result<(), KERIError> {
1003 use crate::keri::core::serdering::Rawifiable;
1004 use crate::keri::db::basing::{EndpointRecord, LocationRecord};
1005
1006 let serder = SerderKERI::from_raw(raw, None)
1007 .map_err(|e| KERIError::ValidationError(format!("invalid reply: {}", e)))?;
1008 let sad = serder.sad();
1009 let field = |obj: &crate::keri::core::serdering::Sadder, k: &str| -> Result<String, KERIError> {
1010 obj.get(k)
1011 .and_then(|v| v.as_str())
1012 .map(str::to_string)
1013 .ok_or_else(|| KERIError::ValidationError(format!("reply missing field {}", k)))
1014 };
1015 let route = field(&sad, "r")?;
1016 let a = match sad.get("a") {
1017 Some(crate::keri::core::serdering::SadValue::Object(a)) => a.clone(),
1018 _ => return Err(KERIError::ValidationError("reply missing data".to_string())),
1019 };
1020
1021 let signed_by = |signer: &str| -> bool {
1023 cigars.iter().any(|cigar| {
1024 cigar.verfer.as_ref().map_or(false, |v| {
1025 v.qb64() == signer && v.verify(cigar.raw(), raw).unwrap_or(false)
1026 })
1027 })
1028 };
1029
1030 match route.as_str() {
1031 "/loc/scheme" => {
1032 let eid = field(&a, "eid")?;
1033 let scheme = field(&a, "scheme")?;
1034 let url = field(&a, "url")?;
1035 if !signed_by(&eid) {
1036 return Err(KERIError::ValidationError(format!(
1037 "/loc/scheme for {} not signed by {}",
1038 eid, eid
1039 )));
1040 }
1041 db.locs
1042 .pin(&[eid.as_bytes(), scheme.as_bytes()], &LocationRecord::new(url))
1043 .map_err(|e| KERIError::DatabaseError(format!("locs: {}", e)))?;
1044 debug!("accepted /loc/scheme {} {} for {}", scheme, field(&a, "url")?, eid);
1045 Ok(())
1046 }
1047 "/end/role/add" | "/end/role/cut" => {
1048 let cid = field(&a, "cid")?;
1049 let role = field(&a, "role")?;
1050 let eid = field(&a, "eid")?;
1051 if !signed_by(&cid) {
1052 return Err(KERIError::ValidationError(format!(
1053 "{} for {} not signed by {}",
1054 route, cid, cid
1055 )));
1056 }
1057 let mut rec = EndpointRecord::new();
1058 rec.allowed = Some(route == "/end/role/add");
1059 db.ends
1060 .pin(&[cid.as_bytes(), role.as_bytes(), eid.as_bytes()], &rec)
1061 .map_err(|e| KERIError::DatabaseError(format!("ends: {}", e)))?;
1062 debug!("accepted {} {} {} {}", route, cid, role, eid);
1063 Ok(())
1064 }
1065 other => {
1066 debug!("reply route {} not yet handled", other);
1067 Ok(())
1068 }
1069 }
1070}
1071
1072#[allow(dead_code)]
1073fn _assert_send() {
1074 fn send<T: Send>() {}
1075 send::<Habery>();
1076 let _ = std::marker::PhantomData::<SerderKERI>;
1077}
1078
1079#[cfg(test)]
1080mod tests {
1081 use super::*;
1082 use crate::cesr::signing::Salter;
1083 use crate::keri::core::serdering::Serder;
1084 use crate::Matter;
1085
1086 fn temp_opts() -> HaberyOptions {
1087 HaberyOptions {
1088 temp: true,
1089 ..Default::default()
1090 }
1091 }
1092
1093 #[test]
1094 fn test_habs_share_one_key_state() -> Result<(), KERIError> {
1095 let mut hby = Habery::open("test-share", temp_opts())?;
1096
1097 let alice = hby.make_hab("alice", MakeHabArgs::default())?.pre.clone().unwrap();
1098 let bob = hby.make_hab("bob", MakeHabArgs::default())?.pre.clone().unwrap();
1099 assert_ne!(alice, bob);
1100
1101 assert!(hby.prefixes().contains(&alice) && hby.prefixes().contains(&bob));
1103 assert!(hby.kevers().contains_key(&alice) && hby.kevers().contains_key(&bob));
1104
1105 {
1107 let mut hab = hby.hab_by_name("alice")?;
1108 hab.rotate(None, None, None, None, None, None, None)?;
1109 }
1110 assert_eq!(hby.kevers()[&alice].sner().unwrap().num(), 1);
1111 assert_eq!(hby.kevers()[&bob].sner().unwrap().num(), 0);
1112
1113 assert!(hby.make_hab("alice", MakeHabArgs::default()).is_err());
1115
1116 hby.reload()?;
1118 assert_eq!(hby.habs().count(), 2);
1119 assert_eq!(hby.kevers()[&alice].sner().unwrap().num(), 1);
1120 assert!(hby.prefixes().contains(&alice));
1121 assert_eq!(hby.hab_by_pre(&bob)?.name, "bob");
1122 Ok(())
1123 }
1124
1125 #[test]
1126 fn test_reopen_restores_habs() -> Result<(), KERIError> {
1127 let dir = tempfile::tempdir().unwrap();
1128 let opts = || HaberyOptions {
1129 head_dir: Some(dir.path().to_path_buf()),
1130 ..Default::default()
1131 };
1132
1133 let pre = {
1134 let mut hby = Habery::open("test-reopen", opts())?;
1135 let mut hab = hby.make_hab("alice", MakeHabArgs::default())?;
1136 hab.rotate(None, None, None, None, None, None, None)?;
1137 hab.pre.clone().unwrap()
1138 };
1139
1140 let mut hby = Habery::open("test-reopen", opts())?;
1141 assert!(hby.prefixes().contains(&pre));
1142 let mut hab = hby.hab_by_name("alice")?;
1143 assert_eq!(hab.pre.as_deref(), Some(pre.as_str()));
1144 assert_eq!(hab.kever()?.sner().unwrap().num(), 1);
1145 hab.rotate(None, None, None, None, None, None, None)?;
1147 assert_eq!(hab.kever()?.sner().unwrap().num(), 2);
1148 Ok(())
1149 }
1150
1151 #[test]
1155 fn test_witness_hab_matches_keripy() -> Result<(), KERIError> {
1156 let dir = tempfile::tempdir().unwrap();
1157 let salt = Salter::new(Some(b"wann-the-witness"), None, None)?.qb64();
1158 let mut hby = Habery::open(
1159 "wan",
1160 HaberyOptions {
1161 head_dir: Some(dir.path().to_path_buf()),
1162 salt: Some(salt),
1163 ..Default::default()
1164 },
1165 )?;
1166 let hab = hby.make_hab(
1167 "wan",
1168 MakeHabArgs {
1169 transferable: Some(false),
1170 ..Default::default()
1171 },
1172 )?;
1173 assert_eq!(
1174 hab.pre.as_deref(),
1175 Some("BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha")
1176 );
1177 assert_eq!(
1179 hab.iserder()?.said(),
1180 Some("EIkO4CUmYXukX4auGU9yaFoQaIicfVZkazQ0A3IO5biT")
1181 );
1182 Ok(())
1183 }
1184
1185 #[test]
1191 fn test_witness_oobi_matches_keripy() -> Result<(), KERIError> {
1192 use crate::keri::Roles;
1193 let fixture = std::fs::read(
1194 std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
1195 .join("src/resources/keripy-wan-oobi.cesr"),
1196 )
1197 .unwrap();
1198 let find = |needle: &[u8]| {
1199 fixture
1200 .windows(needle.len())
1201 .position(|w| w == needle)
1202 .expect("segment in fixture")
1203 };
1204 let starts: Vec<usize> = (0..fixture.len())
1205 .filter(|&i| fixture[i..].starts_with(b"{\"v\":"))
1206 .collect();
1207 assert_eq!(starts.len(), 4);
1208 let seg = |i: usize| {
1209 let end = starts.get(i + 1).copied().unwrap_or(fixture.len());
1210 &fixture[starts[i]..end]
1211 };
1212
1213 let dir = tempfile::tempdir().unwrap();
1214 let salt = Salter::new(Some(b"wann-the-witness"), None, None)?.qb64();
1215 let mut hby = Habery::open(
1216 "wan",
1217 HaberyOptions {
1218 head_dir: Some(dir.path().to_path_buf()),
1219 salt: Some(salt),
1220 ..Default::default()
1221 },
1222 )?;
1223 let hab = hby.make_hab(
1224 "wan",
1225 MakeHabArgs {
1226 transferable: Some(false),
1227 ..Default::default()
1228 },
1229 )?;
1230 let pre = hab.pre.clone().unwrap();
1231 let dt = "2022-01-20T12:57:59.823350+00:00".to_string();
1232
1233 let http = hab.make_loc_scheme(
1234 "http://127.0.0.1:5642/".to_string(),
1235 None,
1236 Some("http".to_string()),
1237 Some(dt.clone()),
1238 )?;
1239 assert_eq!(String::from_utf8_lossy(&http), String::from_utf8_lossy(seg(1)));
1240 let tcp = hab.make_loc_scheme(
1241 "tcp://127.0.0.1:5632/".to_string(),
1242 None,
1243 Some("tcp".to_string()),
1244 Some(dt.clone()),
1245 )?;
1246 assert_eq!(String::from_utf8_lossy(&tcp), String::from_utf8_lossy(seg(2)));
1247 let end = hab.make_end_role(pre.clone(), Some(Roles::Controller), Some(true), Some(dt))?;
1248 assert_eq!(String::from_utf8_lossy(&end), String::from_utf8_lossy(seg(3)));
1249
1250 let kel = hab.replay(None, None)?;
1253 let fs = find(b"-EAB0AAAAAAAAAAAAAAAAAAAAAAA1AAG");
1254 assert_eq!(
1255 String::from_utf8_lossy(&kel[..fs]),
1256 String::from_utf8_lossy(&fixture[..fs])
1257 );
1258 Ok(())
1259 }
1260 #[test]
1265 fn test_witness_receipts_controller_event() -> Result<(), KERIError> {
1266 use crate::keri::db::dbing::keys::dg_key;
1267
1268 let wdir = tempfile::tempdir().unwrap();
1269 let mut wit = Habery::open(
1270 "wan",
1271 HaberyOptions {
1272 head_dir: Some(wdir.path().to_path_buf()),
1273 salt: Some(Salter::new(Some(b"wann-the-witness"), None, None)?.qb64()),
1274 lax: true,
1275 ..Default::default()
1276 },
1277 )?;
1278 let wan = wit
1279 .make_hab("wan", MakeHabArgs { transferable: Some(false), ..Default::default() })?
1280 .pre
1281 .clone()
1282 .unwrap();
1283
1284 let mut ctl = Habery::open("ctl", temp_opts())?;
1285 let (alice, icp) = {
1286 let hab = ctl.make_hab(
1287 "alice",
1288 MakeHabArgs { wits: Some(vec![wan.clone()]), toad: Some(1), ..Default::default() },
1289 )?;
1290 (hab.pre.clone().unwrap(), hab.make_own_event(0, false)?)
1291 };
1292
1293 wit.ingest(&icp, true)?;
1295 assert!(wit.kevers().contains_key(&alice), "witness accepted controller icp");
1296 assert_eq!(wit.kevers()[&alice].wits(), vec![wan.clone()]);
1297 let rct = {
1298 let serder = wit.kevers()[&alice].serder().unwrap();
1299 wit.hab_by_name("wan")?.receipt(&serder)?
1300 };
1301
1302 ctl.ingest(&rct, false)?;
1304 let said = ctl.kevers()[&alice].serder().unwrap().said().unwrap().to_string();
1305 let wigs: Vec<Vec<u8>> = ctl
1306 .db()
1307 .wigs
1308 .get(&[&dg_key(&alice, said.as_bytes())])
1309 .map_err(|e| KERIError::DatabaseError(e.to_string()))?;
1310 assert_eq!(wigs.len(), 1, "controller stored one witness signature");
1311 Ok(())
1312 }
1313
1314 #[test]
1319 fn test_multi_witness_receipt_propagation_and_escrows() -> Result<(), KERIError> {
1320 use crate::keri::db::dbing::keys::{dg_key, sn_key};
1321
1322 let mut wits = Vec::new();
1323 let mut wpres = Vec::new();
1324 for (i, name) in ["wan", "wil", "wes"].iter().enumerate() {
1325 let mut hby = Habery::open(
1326 name,
1327 HaberyOptions {
1328 temp: true,
1329 salt: Some(Salter::new(Some(format!("witness-salt-000{}", i).as_bytes()), None, None)?.qb64()),
1330 lax: true,
1331 ..Default::default()
1332 },
1333 )?;
1334 let pre = hby
1335 .make_hab(name, MakeHabArgs { transferable: Some(false), ..Default::default() })?
1336 .pre
1337 .clone()
1338 .unwrap();
1339 wits.push((name.to_string(), hby));
1340 wpres.push(pre);
1341 }
1342
1343 let mut ctl = Habery::open("ctl", temp_opts())?;
1344 let (alice, icp) = {
1345 let hab = ctl.make_hab(
1346 "alice",
1347 MakeHabArgs { wits: Some(wpres.clone()), toad: Some(2), ..Default::default() },
1348 )?;
1349 (hab.pre.clone().unwrap(), hab.make_own_event(0, false)?)
1350 };
1351 let said = ctl.kevers()[&alice].serder().unwrap().said().unwrap().to_string();
1352 let wig_count = |hby: &Habery| -> usize {
1353 let wigs: Vec<Vec<u8>> = hby.db().wigs.get(&[&dg_key(&alice, said.as_bytes())]).unwrap();
1354 wigs.len()
1355 };
1356
1357 let mut rcts = Vec::new();
1359 for (name, wit) in wits.iter_mut() {
1360 wit.ingest(&icp, true)?;
1361 let serder = wit.kevers()[&alice].serder().unwrap();
1362 let rct = wit.hab_by_name(name)?.receipt(&serder)?;
1363 ctl.ingest(&rct, false)?;
1364 rcts.push(rct);
1365 }
1366 assert_eq!(wig_count(&ctl), 3);
1367
1368 let msgs = ctl.hab_by_name("alice")?.witness_receipt_msgs(0)?;
1370 assert_eq!(msgs.len(), 3);
1371 for ((name, wit), (dest, msg)) in wits.iter_mut().zip(msgs.iter()) {
1372 assert_eq!(dest, &wit.hab_by_name(name)?.pre.clone().unwrap());
1373 wit.ingest(msg, false)?;
1374 assert_eq!(wig_count(wit), 3, "{} holds all three witness signatures", name);
1375 }
1376
1377 let mut val = Habery::open("val", temp_opts())?;
1380 val.ingest(&icp, false)?;
1381 assert!(!val.kevers().contains_key(&alice));
1382 let pwes: Vec<Vec<u8>> = val.db().pwes.get(&[sn_key(&alice, 0)]).unwrap();
1383 assert_eq!(pwes.len(), 1);
1384 val.ingest(&rcts[0], false)?;
1385 assert!(!val.kevers().contains_key(&alice), "one of two witness signatures");
1386 val.ingest(&rcts[1], false)?;
1387 assert!(val.kevers().contains_key(&alice), "accepted with toad = 2 signatures");
1388 let pwes: Vec<Vec<u8>> = val.db().pwes.get(&[sn_key(&alice, 0)]).unwrap();
1389 let ures: Vec<Vec<u8>> = val.db().ures.get(&[sn_key(&alice, 0)]).unwrap();
1390 assert!(pwes.is_empty() && ures.is_empty());
1391
1392 let mut early = Habery::open("early", temp_opts())?;
1395 early.ingest(&rcts[1], false)?;
1396 early.ingest(&rcts[2], false)?;
1397 let ures: Vec<Vec<u8>> = early.db().ures.get(&[sn_key(&alice, 0)]).unwrap();
1398 assert_eq!(ures.len(), 2);
1399 early.ingest(&icp, false)?;
1400 assert!(early.kevers().contains_key(&alice));
1401 assert_eq!(wig_count(&early), 2);
1402 let ures: Vec<Vec<u8>> = early.db().ures.get(&[sn_key(&alice, 0)]).unwrap();
1403 assert!(ures.is_empty());
1404 Ok(())
1405 }
1406
1407 #[test]
1411 fn test_complete_delegation_waits_for_witnessed_anchor() -> Result<(), KERIError> {
1412 use crate::keri::db::dbing::keys::dg_key;
1413
1414 let mut wan = Habery::open("wan", temp_opts())?;
1416 let wpre = wan
1417 .make_hab("wan", MakeHabArgs { transferable: Some(false), ..Default::default() })?
1418 .pre
1419 .clone()
1420 .unwrap();
1421 let mut tor = Habery::open("tor", temp_opts())?;
1422 let (tpre, ticp) = {
1423 let hab = tor.make_hab(
1424 "tor",
1425 MakeHabArgs { wits: Some(vec![wpre.clone()]), toad: Some(1), ..Default::default() },
1426 )?;
1427 (hab.pre.clone().unwrap(), hab.make_own_event(0, false)?)
1428 };
1429 let witness = |wan: &mut Habery, msg: &[u8]| -> Result<Vec<u8>, KERIError> {
1430 wan.ingest(msg, true)?;
1431 let serder = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(msg, None)?;
1432 let accepted = wan.kevers()[&serder.pre().unwrap()].serder().unwrap();
1433 wan.hab_by_name("wan")?.receipt(&accepted)
1434 };
1435 let trct = witness(&mut wan, &ticp)?;
1436 tor.ingest(&trct, false)?;
1437
1438 let mut dee = Habery::open("dee", temp_opts())?;
1440 let dpre = dee
1441 .make_hab("dee", MakeHabArgs { delpre: Some(tpre.clone()), ..Default::default() })?
1442 .pre
1443 .clone()
1444 .unwrap();
1445 let dsaid = dee.kevers()[&dpre].serder().unwrap().said().unwrap().to_string();
1446 assert_eq!(dee.complete_delegation(&dpre, 0)?, None, "delegator KEL unknown");
1447
1448 dee.ingest(&ticp, false)?;
1449 dee.ingest(&trct, false)?;
1450 assert_eq!(dee.complete_delegation(&dpre, 0)?, None, "no anchor yet");
1451
1452 let seal: SadValue =
1454 serde_json::from_str(&format!(r#"{{"i":"{}","s":"0","d":"{}"}}"#, dpre, dsaid)).unwrap();
1455 let ixn = tor.hab_by_name("tor")?.interact(Some(vec![seal]))?;
1456 dee.ingest(&ixn, false)?;
1457 assert_eq!(dee.complete_delegation(&dpre, 0)?, None, "anchor not fully witnessed");
1458
1459 let ircpt = witness(&mut wan, &ixn)?;
1460 dee.ingest(&ircpt, false)?;
1461 let msg = dee.complete_delegation(&dpre, 0)?.expect("approved");
1462
1463 let isaid = tor.kevers()[&tpre].serder().unwrap().said().unwrap().to_string();
1464 let couple = format!("{}{}", crate::cesr::seqner::Seqner::from_sn(1).qb64(), isaid);
1465 let stored: Option<Vec<u8>> = dee.db().aess.get(&[&dg_key(&dpre, &dsaid)]).unwrap();
1466 assert_eq!(stored, Some(couple.clone().into_bytes()));
1467 let text = String::from_utf8_lossy(&msg);
1468 assert!(text.contains(&format!("-GAB{}", couple)), "dip carries the source seal couple: {}", text);
1469 Ok(())
1470 }
1471
1472 #[test]
1477 fn test_approve_delegation_round_trip() -> Result<(), KERIError> {
1478 let mut tor = Habery::open("tor", temp_opts())?;
1479 let tpre = tor.make_hab("tor", MakeHabArgs::default())?.pre.clone().unwrap();
1480 let ticp = tor.hab_by_name("tor")?.make_own_event(0, false)?;
1481
1482 let mut dee = Habery::open("dee", temp_opts())?;
1483 dee.ingest(&ticp, false)?;
1484 let dpre = dee
1485 .make_hab("dee", MakeHabArgs { delpre: Some(tpre.clone()), ..Default::default() })?
1486 .pre
1487 .clone()
1488 .unwrap();
1489 let dip = dee.db().clone_evt_msg_at(&dpre, 0)?;
1490
1491 tor.ingest(&dip, false)?;
1493 assert!(!tor.kevers().contains_key(&dpre));
1494 let pending = tor.pending_delegations()?;
1495 assert_eq!(pending.len(), 1);
1496 assert_eq!((pending[0].0.as_str(), pending[0].1), (dpre.as_str(), 0));
1497
1498 let anchor = tor.approve_delegation("tor", &dpre, 0, false)?;
1499 assert!(tor.kevers().contains_key(&dpre), "accepted with the anchoring event as its seal");
1500 assert!(tor.pending_delegations()?.is_empty());
1501
1502 dee.ingest(&anchor, false)?;
1505 let done = dee.complete_delegation(&dpre, 0)?.expect("approved");
1506 let mut val = Habery::open("val", temp_opts())?;
1507 val.ingest(&ticp, false)?;
1508 val.ingest(&anchor, false)?;
1509 val.ingest(&done, false)?;
1510 assert!(val.kevers().contains_key(&dpre), "third party validates the seal couple");
1511
1512 let mut val2 = Habery::open("val2", temp_opts())?;
1514 val2.ingest(&ticp, false)?;
1515 val2.ingest(&dip, false)?;
1516 assert!(!val2.kevers().contains_key(&dpre));
1517 Ok(())
1518 }
1519
1520 #[test]
1524 fn test_out_of_order_escrow() -> Result<(), KERIError> {
1525 let mut ctl = Habery::open("ctl", temp_opts())?;
1526 let pre = ctl.make_hab("ctl", MakeHabArgs::default())?.pre.clone().unwrap();
1527 ctl.hab_by_name("ctl")?.interact(None)?;
1528 ctl.hab_by_name("ctl")?.rotate(None, None, None, None, None, None, None)?;
1529 ctl.hab_by_name("ctl")?.interact(None)?;
1530 let msg = |sn| ctl.db().clone_evt_msg_at(&pre, sn);
1531 let (icp, ixn1, rot2, ixn3) = (msg(0)?, msg(1)?, msg(2)?, msg(3)?);
1532 let sn = |hby: &Habery| hby.kevers().get(&pre).and_then(|k| k.sner()).map(|s| s.num());
1533 let escrowed = |hby: &Habery| {
1534 hby.db().ooes.get_item_iter(&[b""], false).map(|items| items.len()).unwrap_or(0)
1535 };
1536
1537 let mut val = Habery::open("val", temp_opts())?;
1539 val.ingest(&ixn3, false)?;
1540 val.ingest(&rot2, false)?;
1541 assert_eq!(sn(&val), None);
1542 assert_eq!(escrowed(&val), 2);
1543
1544 val.ingest(&icp, false)?;
1546 assert_eq!(sn(&val), Some(0u32.into()));
1547 assert_eq!(escrowed(&val), 2);
1548 val.ingest(&ixn1, false)?;
1549 assert_eq!(sn(&val), Some(3u32.into()), "sn 2 and 3 accepted from escrow in one pass");
1550 assert_eq!(escrowed(&val), 0);
1551
1552 let mut val2 = Habery::open("val2", temp_opts())?;
1554 val2.ingest(&ixn1, false)?;
1555 val2.ingest(&ixn1, false)?;
1556 assert_eq!(escrowed(&val2), 1);
1557
1558 let said = <SerderKERI as crate::keri::core::serdering::Rawifiable>::from_raw(&ixn1, None)?.said().unwrap().to_string();
1560 let old = (chrono::Utc::now() - chrono::Duration::seconds(Kevery::TIMEOUT_OOE as i64 + 1))
1561 .to_rfc3339();
1562 val2.db().dtss.pin(&[pre.as_str(), said.as_str()], &[&old.as_bytes()])?;
1563 val2.process_escrows();
1564 assert_eq!(escrowed(&val2), 0);
1565 Ok(())
1566 }
1567
1568 #[test]
1572 fn test_ingest_keripy_witness_oobi() -> Result<(), KERIError> {
1573 let wan = "BBilc4-L3tFUnfM_wJr4S4OJanAv_VmF_dJNN6vkf2Ha";
1574 let oobi = std::fs::read(
1575 std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
1576 .join("src/resources/keripy-wan-oobi.cesr"),
1577 )
1578 .unwrap();
1579
1580 let mut hby = Habery::open("resolver", temp_opts())?;
1581 assert_eq!(hby.ingest(&oobi, false)?, 4);
1582 assert!(hby.kevers().contains_key(wan), "witness KEL accepted");
1583 hby.reload()?; let url = |scheme: &str| {
1586 hby.db()
1587 .locs
1588 .get(&[wan.as_bytes(), scheme.as_bytes()])
1589 .unwrap()
1590 .map(|r| r.url)
1591 };
1592 assert_eq!(url("http").as_deref(), Some("http://127.0.0.1:5642/"));
1593 assert_eq!(url("tcp").as_deref(), Some("tcp://127.0.0.1:5632/"));
1594 let end = hby
1595 .db()
1596 .ends
1597 .get(&[wan.as_bytes(), b"controller".as_slice(), wan.as_bytes()])
1598 .unwrap()
1599 .expect("end role stored");
1600 assert_eq!(end.allowed, Some(true));
1601
1602 let mut tampered = oobi.clone();
1604 let pos = tampered
1605 .windows(22)
1606 .position(|w| w == b"http://127.0.0.1:5642/")
1607 .unwrap();
1608 tampered[pos + 17] = b'3'; let mut fresh = Habery::open("resolver2", temp_opts())?;
1610 assert!(fresh.ingest(&tampered, false).is_err());
1611 Ok(())
1612 }
1613
1614 #[test]
1618 fn test_join_group_inception() -> Result<(), KERIError> {
1619 use crate::cesr::tholder::TholderSith;
1620 use crate::keri::core::eventing::incept::InceptionEventBuilder;
1621 use crate::keri::core::eventing::messagize;
1622
1623 let mut a = Habery::open("grp-alice", temp_opts())?;
1624 let mut b = Habery::open("grp-bob", temp_opts())?;
1625 let apre = a.make_hab("alice", MakeHabArgs::default())?.pre.clone().unwrap();
1626 let bpre = b.make_hab("bob", MakeHabArgs::default())?.pre.clone().unwrap();
1627 let aicp = a.hab_by_pre(&apre)?.make_own_inception(false)?;
1628 let bicp = b.hab_by_pre(&bpre)?.make_own_inception(false)?;
1629 a.ingest(&bicp, false)?;
1630 b.ingest(&aicp, false)?;
1631
1632 let smids = vec![apre.clone(), bpre.clone()];
1633 let (merfers, migers) = a.extract_merfers_migers(&smids, None)?;
1634 let icp = InceptionEventBuilder::new(merfers.iter().map(|v| v.qb64()).collect())
1635 .with_ndigs(migers.iter().map(|d| d.qb64()).collect())
1636 .with_isith(TholderSith::HexString("2".to_string()))
1637 .with_nsith(TholderSith::HexString("2".to_string()))
1638 .with_code("E".to_string())
1639 .build()?;
1640 let gpre = icp.pre().unwrap();
1641 let asigs = a.sign_as_member(&apre, icp.raw(), &merfers)?;
1642 assert_eq!(asigs[0].index(), 0);
1643 let proposal = messagize(&icp, Some(&asigs), None, None, None, false).unwrap();
1644
1645 let reversed = vec![bpre.clone(), apre.clone()];
1648 assert!(b.join_group_inception("grp", "bob", &reversed, None, &proposal).is_err());
1649 assert!(b.group_members(&gpre).is_none());
1650 assert!(b.hab_by_name("grp").is_err());
1651
1652 let full = b.join_group_inception("grp", "bob", &smids, None, &proposal)?;
1654 assert!(b.kevers().contains_key(&gpre));
1655 assert_eq!(b.group_members(&gpre).unwrap().mid, bpre);
1656 assert!(b.kevery().locals.groups.contains(&gpre));
1657 assert_eq!(b.hab_by_name("grp")?.pre.as_deref(), Some(gpre.as_str()));
1658
1659 a.join_group_inception("grp", "alice", &smids, None, &full)?;
1661 assert_eq!(
1662 a.kevers()[&gpre].serder().unwrap().said(),
1663 b.kevers()[&gpre].serder().unwrap().said()
1664 );
1665
1666 b.reload()?;
1668 assert_eq!(
1669 b.group_members(&gpre).cloned(),
1670 Some(GroupMembers { mid: bpre.clone(), smids: smids.clone(), rmids: smids.clone() })
1671 );
1672 Ok(())
1673 }
1674
1675 #[test]
1680 fn test_make_group_hab_and_partial_signature_escrow() -> Result<(), KERIError> {
1681 use crate::cesr::tholder::TholderSith;
1682 use crate::keri::core::eventing::messagize;
1683 use crate::keri::core::serdering::Rawifiable;
1684
1685 let mut hbys: Vec<Habery> = ["pse-alice", "pse-bob", "pse-carol"]
1686 .iter()
1687 .map(|n| Habery::open(n, temp_opts()))
1688 .collect::<Result<_, _>>()?;
1689 let names = ["alice", "bob", "carol"];
1690 let mut pres = Vec::new();
1691 let mut icps = Vec::new();
1692 for (hby, name) in hbys.iter_mut().zip(names) {
1693 let pre = hby.make_hab(name, MakeHabArgs::default())?.pre.clone().unwrap();
1694 icps.push(hby.hab_by_pre(&pre)?.make_own_inception(false)?);
1695 pres.push(pre);
1696 }
1697 for (i, hby) in hbys.iter_mut().enumerate() {
1698 for (j, icp) in icps.iter().enumerate() {
1699 if i != j {
1700 hby.ingest(icp, false)?;
1701 }
1702 }
1703 }
1704 let pses = |hby: &Habery| hby.db().pses.get_item_iter(&[b"" as &[u8]], false).unwrap().len();
1705 let three = || Some(TholderSith::HexString("3".to_string()));
1706 let (alice, rest) = hbys.split_at_mut(1);
1707 let (bob, carol) = rest.split_at_mut(1);
1708 let (alice, bob, carol) = (&mut alice[0], &mut bob[0], &mut carol[0]);
1709
1710 let proposal = alice.make_group_hab("grp", "alice", &pres, None, three(), three())?;
1712 let serder = SerderKERI::from_raw(&proposal, None)?;
1713 let gpre = serder.pre().unwrap();
1714 assert!(!alice.kevers().contains_key(&gpre));
1715 assert_eq!(pses(alice), 1);
1716 assert_eq!(alice.group_members(&gpre).unwrap().mid, pres[0]);
1717
1718 let bob_full = bob.join_group_inception("grp", "bob", &pres, None, &proposal)?;
1720 assert!(!bob.kevers().contains_key(&gpre));
1721 assert_eq!(pses(bob), 1);
1722
1723 carol.join_group_inception("grp", "carol", &pres, None, &bob_full)?;
1725 assert!(carol.kevers().contains_key(&gpre));
1726
1727 let (merfers, _) = carol.extract_merfers_migers(&pres, None)?;
1729 let own = |hby: &mut Habery, mid: &str| -> Vec<u8> {
1730 let sigs = hby.sign_as_member(mid, serder.raw(), &merfers).unwrap();
1731 messagize(&serder, Some(&sigs), None, None, None, false).unwrap()
1732 };
1733 let carol_sig = own(carol, &pres[2]);
1734 let bob_sig = own(bob, &pres[1]);
1735
1736 bob.ingest(&carol_sig, true)?;
1738 assert!(bob.kevers().contains_key(&gpre));
1739 assert_eq!(pses(bob), 0);
1740
1741 alice.ingest(&bob_sig, true)?;
1743 assert!(!alice.kevers().contains_key(&gpre));
1744 alice.ingest(&carol_sig, true)?;
1745 assert!(alice.kevers().contains_key(&gpre));
1746 assert_eq!(pses(alice), 0);
1747
1748 let said = |hby: &Habery| hby.kevers()[&gpre].serder().unwrap().said().unwrap().to_string();
1749 assert_eq!(said(alice), said(bob));
1750 assert_eq!(said(bob), said(carol));
1751 Ok(())
1752 }
1753}