Skip to main content

libkeri/keri/app/
habery.rs

1//! Habery: single owner of the keystore, database and event processors shared by
2//! all local identifiers (Habs), the Rust counterpart of keripy's `Habery`.
3//!
4//! Memory model: a Habery owns exactly one `Manager` (and its `Keeper`), one
5//! `Baser`, one `Kevery`, one `Revery` and one handler-less `Parser`. A [`Hab`]
6//! is a short-lived view that borrows those components, so every Hab sees the
7//! same key state and the same set of local prefixes. Nothing here locks,
8//! spawns threads, or is async: callers decide where a Habery lives (on the
9//! stack in a CLI, on an owner thread in a server, behind their own `Mutex`).
10//!
11//! On `open`, state is rebuilt from the database (local Habs, local prefixes,
12//! and key state for every known AID), so short-lived and long-lived users run
13//! the same code.
14
15use 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/// Options for [`Habery::open`].
43#[derive(Default)]
44pub struct HaberyOptions {
45    /// Optional extra directory level, like keripy's `--base`.
46    pub base: Option<String>,
47    /// Root directory for the database instead of `~/.keri` (absolute paths OK).
48    pub head_dir: Option<std::path::PathBuf>,
49    /// Use a temporary database (removed on drop) and fast key stretching.
50    pub temp: bool,
51    /// qb64 salt for deriving keys. Only used when the keystore is created.
52    pub salt: Option<String>,
53    /// Configuration file (curls, iurls, ...).
54    pub cf: Option<Arc<Configer>>,
55    /// Kevery `lax` mode: true accepts own receipts from any source (witnesses).
56    pub lax: bool,
57}
58
59/// Inception parameters for [`Habery::make_hab`]. All fields default to the
60/// same values as `Hab::make` (and keripy's `makeHab`).
61#[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    /// Anchors for the inception event's `a` list (keripy `makeHab(data=...)`).
74    pub data: Option<Vec<SadValue>>,
75    pub algo: Option<Algos>,
76    pub salt: Option<Vec<u8>>,
77    pub tier: Option<Tiers>,
78}
79
80/// Per-Hab state the Habery keeps between views.
81#[derive(Debug, Clone)]
82struct HabState {
83    name: String,
84    ns: Option<String>,
85    pre: String,
86    /// Set when this Hab is a group: its local member and the group's members.
87    group: Option<GroupMembers>,
88}
89
90/// Membership of a local group (multisig) Hab (keripy `GroupHab` mhab/smids/rmids).
91#[derive(Debug, Clone, PartialEq, Eq)]
92pub struct GroupMembers {
93    /// Prefix of the local member Hab that signs for this Habery.
94    pub mid: String,
95    /// Signing members: each contributes its current key, in this order.
96    pub smids: Vec<String>,
97    /// Rotating members: each contributes its next key digest, in this order.
98    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    /// Local Habs keyed by prefix.
111    habs: IndexMap<String, HabState>,
112}
113
114impl Habery {
115    /// Open (creating if needed) the keystore and database named `name`, then
116    /// rebuild in-memory state from the database.
117    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), // local: own Habs' events are a protected source
155            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    /// Rebuild key state, local prefixes and the Hab index from the database.
178    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    /// Incept a new local identifier named `name` and return a view of it.
240    pub fn make_hab(&mut self, name: &str, args: MakeHabArgs) -> Result<Hab<'_>, KERIError> {
241        self.make_hab_ns(name, None, args)
242    }
243
244    /// Like [`Habery::make_hab`] but within namespace `ns`.
245    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    /// View of the local Hab with prefix `pre`.
309    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    /// View of the local Hab named `name` (no namespace).
319    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    /// Parse `ims` and route every message to the Kevery/Revery. `local` marks
354    /// the source as protected (own messages) or not (anything from a peer).
355    ///
356    /// An event short of signatures or witness signatures, an event whose
357    /// prior event hasn't arrived, an event that conflicts with one already
358    /// accepted, or a receipt for an event not seen yet, is escrowed rather than treated as a failure; after
359    /// routing, the escrows are processed, so signatures and receipts that
360    /// arrive separately complete the event. Any other failure stops at that
361    /// message and is returned.
362    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                // Escrowed: waiting for more signatures, witness signatures,
369                // or the event a receipt is for.
370                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    /// Retry escrowed events (keripy runs these continuously in its doers;
391    /// here the owner calls this, and [`Habery::ingest`] does after each batch).
392    pub fn process_escrows(&mut self) {
393        self.kvy.process_escrows();
394    }
395
396    /// Names and prefixes of local Habs, in creation order.
397    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    /// Filesystem path of the underlying database, if not temporary.
406    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    /// Key state for every known AID (local and remote).
415    pub fn kevers(&self) -> &HashMap<String, Kever> {
416        &self.kvy.kevers
417    }
418
419    /// Prefixes of all local identifiers.
420    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
455/// Group (multisig) identifiers: keripy `Habery.makeGroupHab` / `joinGroupHab`
456/// and `GroupHab.sign`.
457impl Habery {
458    /// Membership of the local group Hab `pre`, or None if it is not a group.
459    pub fn group_members(&self, pre: &str) -> Option<&GroupMembers> {
460        self.habs.get(pre).and_then(|h| h.group.as_ref())
461    }
462
463    /// Current signing keys of `smids` and next key digests of `rmids` (default
464    /// `smids`), one each, in member order, from their KELs (keripy
465    /// `extractMerfersMigers`). Every member must have exactly one key.
466    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); // an abandoned member has none
500        }
501        Ok((merfers, migers))
502    }
503
504    /// Record a local group Hab `group` with prefix `pre` whose local member is
505    /// the Hab `mhab_name` (keripy `joinGroupHab`). Does not process any event.
506    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    /// Join a group whose inception another member proposed (keripy
520    /// `kli multisig join`): check that `proposal` (a group `icp` with the
521    /// proposer's signatures) is the inception the members' KELs imply, record
522    /// the group Hab, add this member's signature and process the event.
523    ///
524    /// Returns the inception with every signature collected so far, to send
525    /// back to the other members. If those meet the signing threshold the
526    /// group is accepted now; otherwise the event waits in the
527    /// partial-signature escrow for the remaining members' signatures.
528    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        // The proposal must commit to exactly the members' keys and next digests.
569        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        // Record the group first so key state treats it as locally membered.
588        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    /// Propose a new group identifier `group` with local member `mhab_name`
607    /// (keripy `makeGroupHab`): build the group inception from the members'
608    /// current keys and next-key digests, sign it as the local member and
609    /// process it. Unless this one signature meets `isith`, the event waits in
610    /// the partial-signature escrow until the other members' signatures are
611    /// ingested.
612    ///
613    /// Returns the inception with this member's signature, for the other
614    /// members to join (see [`Habery::join_group_inception`]). Thresholds
615    /// default as in keripy: `isith` is a majority of the keys, `nsith`
616    /// is `isith`.
617    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    /// Process a group event this Habery signed, as a local source. Being
658    /// escrowed for the other members' signatures is expected, not an error.
659    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    /// Sign `ser` (a group event whose signing keys are `verfers`) with the
677    /// local member `mid`'s contributed key, indexed at that key's position in
678    /// `verfers` (keripy `GroupHab.sign`, non-rotation case).
679    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        // Not a rotation, so no prior-next index: the signature is current
700        // only (keripy: app/habbing.py GroupHab.sign, pni = None).
701        hab.sign(ser, Some(vec![mverfer]), Some(true), Some(vec![csi]), Some(vec![None]), None)
702    }
703
704    /// Complete a local delegated event once its delegator has approved it
705    /// (keripy: app/delegating.py Anchorer.processUnanchoredEscrow).
706    ///
707    /// `pre` must be a local delegated AID whose event at `sn` (a `dip` or
708    /// `drt`) has been accepted. Approval is the delegator anchoring the seal
709    /// `{i: pre, s: sn, d: said}` in a fully witnessed event of its own KEL, as
710    /// this Habery has it: ingest the delegator's KEL (as served by its
711    /// witnesses) first. Nothing the delegate or the delegator sends directly
712    /// counts as approval.
713    ///
714    /// On approval, stores the source seal couple of the delegating event in
715    /// `aess` and returns the event cloned with all its attachments (now with
716    /// `-G`), ready to send to this AID's witnesses. Returns `None` while the
717    /// delegator's KEL is unknown or has no fully witnessed anchor yet.
718    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); // delegator's KEL not seen yet
735        };
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    /// Delegated events waiting for approval by a local delegator: `(pre, sn,
764    /// said)` from the delegable escrow, and from the misfit escrow those whose
765    /// delegator is local (a delegator that fetched the event itself, e.g.
766    /// from the delegate's witnesses).
767    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    /// Approve delegated event `sn` of `delegate` as the local delegator
800    /// `delegator_alias` (keripy `kli delegate confirm`): anchor the seal
801    /// `{i, s, d}` in a new interaction (or, with `rotate`, rotation) event,
802    /// then process the escrowed delegated event as local with that event as
803    /// its source seal couple, as keripy main's confirm does. Returns the
804    /// anchoring event, for the delegator's witnesses to receipt.
805    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
939/// Route one parsed message to the processor that handles it. Shared by
940/// [`Habery::ingest`] and `BaseHab::ingest_local` so there is one dispatch path.
941pub 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
995/// Accept a reply (`rpy`) signed by a non-transferable AID: the `/loc/scheme`
996/// and `/end/role/{add,cut}` replies a witness serves in its OOBI.
997///
998/// The signer must be the AID the reply speaks for (`eid` for a location,
999/// `cid` for an end role). Accepted data is stored where `Hab::fetch_urls` /
1000/// `fetch_end` read it. Not yet implemented: keripy's BADA rule (a later `dt`
1001/// replaces an earlier one; older ones are ignored) - the last reply wins.
1002fn 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    // Verified signature by `signer` over the reply.
1022    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        // Both prefixes are local and have key state in the single Kevery.
1102        assert!(hby.prefixes().contains(&alice) && hby.prefixes().contains(&bob));
1103        assert!(hby.kevers().contains_key(&alice) && hby.kevers().contains_key(&bob));
1104
1105        // A rotation through a fresh view is visible to the Habery afterwards.
1106        {
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        // Duplicate names are rejected.
1114        assert!(hby.make_hab("alice", MakeHabArgs::default()).is_err());
1115
1116        // reload() rebuilds the same state from the database.
1117        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        // Keys survived too: the reopened Hab can keep rotating.
1146        hab.rotate(None, None, None, None, None, None, None)?;
1147        assert_eq!(hab.kever()?.sner().unwrap().num(), 2);
1148        Ok(())
1149    }
1150
1151    /// Same inputs as keripy's `kli witness demo` for `wan`:
1152    /// Habery(salt=Salter(raw=b"wann-the-witness").qb64, temp=False)
1153    /// then makeHab(name="wan", transferable=False).
1154    #[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        // SAID of wan's inception event as served by keripy's witness OOBI.
1178        assert_eq!(
1179            hab.iserder()?.said(),
1180            Some("EIkO4CUmYXukX4auGU9yaFoQaIicfVZkazQ0A3IO5biT")
1181        );
1182        Ok(())
1183    }
1184
1185    /// The OOBI a keripy witness serves for itself (captured from `kli witness
1186    /// demo` in src/resources/keripy-wan-oobi.cesr): own KEL, then /loc/scheme
1187    /// replies for each curl and an /end/role/add controller reply, all stamped
1188    /// with the config file `dt`. Replies are deterministic, so they must match
1189    /// byte for byte.
1190    #[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        // KEL replay: identical up to the first-seen datetime (which is when
1251        // each witness first saw its own icp).
1252        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    /// keripy witness flow (`kli incept --receipt-endpoint` against a witness's
1261    /// `/receipts`): controller sends its signed icp, the witness accepts it as a
1262    /// local source because it is a witness for it, returns a receipt, and the
1263    /// controller stores the witness signature.
1264    #[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        // Witness side (keripy ReceiptEnd.on_post): parse as local, then receipt.
1294        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        // Controller side (keripy Receiptor): parse the receipt.
1303        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    /// Three witnesses, toad 2: the controller collects every receipt, then
1315    /// propagates each witness the other two receipts so all three hold a
1316    /// fully witnessed event. Validators that see the event before enough
1317    /// receipts (or the receipts before the event) escrow and then accept it.
1318    #[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        // Phase 1: every witness accepts and receipts; the controller stores all three.
1358        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        // Phase 2: each witness gets the other two receipts.
1369        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        // A validator that gets the event first escrows it as partially
1378        // witnessed; one receipt is not enough for toad 2, two are.
1379        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        // A validator that gets the receipts before the event escrows them as
1393        // unverified and accepts the event as soon as it arrives.
1394        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    /// A delegate completes its inception only once its delegator's KEL, as
1408    /// the delegate has it, holds a fully witnessed event anchoring the
1409    /// delegate's seal; then the `dip` carries the source seal couple.
1410    #[test]
1411    fn test_complete_delegation_waits_for_witnessed_anchor() -> Result<(), KERIError> {
1412        use crate::keri::db::dbing::keys::dg_key;
1413
1414        // Witness wan and delegator tor (toad 1).
1415        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        // Delegate dee: its own dip is accepted locally before approval.
1439        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        // tor anchors dee's seal; until wan receipts it, it isn't approval.
1453        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    /// A local delegator approves a delegated inception it received from a
1473    /// remote source: the dip waits in the misfit escrow, approval anchors its
1474    /// seal and accepts it with that source seal couple, the delegate then
1475    /// completes it, and a third party accepts the completed dip.
1476    #[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        // Remote dip for a locally delegated AID: escrowed, not accepted.
1492        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        // The delegate sees the anchor and completes; a third party accepts
1503        // the completed dip from the delegator's KEL plus the dip with -G.
1504        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        // Without the couple a third party can't place the dip yet.
1513        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    /// Events that arrive before their prior event wait in the out-of-order
1521    /// escrow (keripy: core/eventing.py Kevery.escrowOOEvent) and are accepted,
1522    /// in order, once the gap is filled.
1523    #[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        // Unknown prefix: a non-inception event is escrowed, not an error.
1538        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        // Known prefix with a gap: escrowed until sn 1 arrives.
1545        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        // Re-sending an escrowed event doesn't duplicate the entry.
1553        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        // Older than TIMEOUT_OOE: dropped on the next pass.
1559        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    /// Resolving a keripy witness OOBI: ingest the stream keripy served
1569    /// (KEL + /loc/scheme + /end/role replies) and the witness's key state and
1570    /// verified endpoints become available locally.
1571    #[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()?; // state written while ingesting must reload (next process)
1584
1585        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        // A reply whose signature does not match is rejected.
1603        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'; // 5642 -> 5632 in the http loc scheme
1609        let mut fresh = Habery::open("resolver2", temp_opts())?;
1610        assert!(fresh.ingest(&tampered, false).is_err());
1611        Ok(())
1612    }
1613
1614    /// Two single-key members in separate Haberys form a 2-of-2 group: alice
1615    /// proposes the inception (as keripy's makeGroupHab does), bob joins it,
1616    /// and alice then accepts the fully signed result.
1617    #[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        // Members listed in another order imply different keys: rejected, and
1646        // nothing is recorded.
1647        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        // Bob joins: adds his signature at index 1, which meets kt=2.
1653        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        // Alice records the same group from the fully signed inception.
1660        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        // Group membership survives a reload from the database.
1667        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    /// Three members, 3-of-3: alice proposes with make_group_hab, bob joins
1676    /// (still short, so escrowed), carol joins with both signatures and is the
1677    /// first to accept. Alice and bob then complete from their escrows when
1678    /// the missing members' own signatures arrive one at a time.
1679    #[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        // Alice proposes: one of three signatures, so escrowed, not accepted.
1711        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        // Bob joins: two of three, still escrowed.
1719        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 joins with alice's and bob's signatures: all three, accepted.
1724        carol.join_group_inception("grp", "carol", &pres, None, &bob_full)?;
1725        assert!(carol.kevers().contains_key(&gpre));
1726
1727        // Each member sends only its own signature from here on.
1728        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 had alice+bob escrowed; carol's signature completes it.
1737        bob.ingest(&carol_sig, true)?;
1738        assert!(bob.kevers().contains_key(&gpre));
1739        assert_eq!(pses(bob), 0);
1740
1741        // Alice gets bob's signature (still short, stays escrowed), then carol's.
1742        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}