Skip to main content

libkeri/keri/app/keeping/
manager.rs

1use crate::cesr::diger::Diger;
2use crate::cesr::prefixer::Prefixer;
3use crate::cesr::signing::{Decrypter, Encrypter, Salter, Sigmat, Signer};
4use crate::cesr::tholder::{Tholder, TholderSith};
5use crate::cesr::verfer::Verfer;
6use crate::cesr::{mtr_dex, Parsable, Tiers};
7use crate::keri::app::keeping::creators::{Algos, Creatory};
8use crate::keri::app::keeping::keeper::{PrePrm, PreSit, PubLot, PubSet};
9use crate::keri::app::keeping::Keeper;
10use crate::keri::app::ri_key;
11use crate::keri::help::helping::nowiso8601;
12use crate::keri::KERIError;
13use crate::Matter;
14use chrono::Utc;
15use sodiumoxide::crypto::sign::SecretKey;
16use std::collections::VecDeque;
17
18/// Manager struct for key pair creation, storage, retrieval, and message signing
19///
20/// # Attributes
21/// * `ks` - Keeper instance for storing public and private keys
22/// * `encrypter` - Instance for encrypting secrets, derived from aeid
23/// * `decrypter` - Instance for decrypting secrets, derived from seed
24/// * `inited` - Flag indicating if manager is fully initialized
25/// * `_seed` - Private signing key for the aeid (memory only, never persisted)
26/// * `_inits` - Initialization parameters for later setup
27pub struct Manager {
28    /// Key store LMDB database instance for storing public and private keys
29    pub ks: Keeper,
30
31    /// Instance for encrypting secrets. Public encryption key derived from aeid
32    pub encrypter: Option<Encrypter>,
33
34    /// Instance for decrypting secrets. Private decryption key derived from seed
35    pub decrypter: Option<Decrypter>,
36
37    /// True means fully initialized wrt database. False means not yet fully initialized
38    pub inited: bool,
39
40    /// qb64b private-signing key (seed) for the aeid
41    /// MUST NOT be persisted to database, memory only
42    /// Acts as authentication, authorization, and decryption secret
43    _seed: Vec<u8>,
44}
45
46impl Manager {
47    /// Create new Manager instance
48    ///
49    /// # Parameters
50    /// * `ks` - Optional Keeper instance
51    /// * `seed` - Optional qb64 private signing key for the aeid
52    /// * `kwa` - Additional parameters to pass to setup method
53    ///
54    /// # Returns
55    /// * `Result<Self, DBError>` - Result containing new Manager or error
56    pub fn new(
57        ks: Keeper,
58        seed: Option<Vec<u8>>,
59        aeid: Option<Vec<u8>>,
60        pidx: Option<usize>,
61        algo: Option<Algos>,
62        salt: Option<Vec<u8>>,
63        tier: Option<Tiers>,
64    ) -> Result<Self, KERIError> {
65        let mut manager = Manager {
66            ks,
67            encrypter: None,
68            decrypter: None,
69            _seed: seed.unwrap_or_default(),
70            inited: false,
71        };
72
73        if manager.ks.opened() {
74            manager.setup(aeid, pidx, algo, salt, tier)?;
75        }
76
77        Ok(manager)
78    }
79
80    /// Set up manager root or global attributes and properties
81    ///
82    /// # Parameters
83    /// * `aeid` - qb64b non-transferable identifier prefix for authentication and encryption
84    /// * `pidx` - Index of next new created key pair sequence
85    /// * `algo` - Root algorithm for creating key pairs
86    /// * `salt` - qb64 of root salt
87    /// * `tier` - Default security tier for root salt
88    ///
89    /// # Returns
90    /// * `Result<(), DBError>` - Success or error
91    pub fn setup(
92        &mut self,
93        aeid: Option<Vec<u8>>,
94        pidx: Option<usize>,
95        algo: Option<Algos>,
96        salt: Option<Vec<u8>>,
97        tier: Option<Tiers>,
98    ) -> Result<(), KERIError> {
99        if !self.ks.opened() {
100            return Err(KERIError::ManagerError(
101                "Attempt to setup Manager closed keystore database .ks.".to_string(),
102            ));
103        }
104
105        let aeid = aeid.unwrap_or_default();
106        let pidx = pidx.unwrap_or(0);
107        let algo = algo.unwrap_or_else(|| Algos::Salty);
108
109        let salt = match salt {
110            Some(mut s) => {
111                // Validate salt
112                if Salter::from_qb64b(&mut s, None)?.qb64b() != s {
113                    return Err(KERIError::ManagerError(format!(
114                        "Invalid qb64 for salt={:?}",
115                        s
116                    )));
117                }
118                s
119            }
120            None => Salter::new(None, None, None)?.qb64b(),
121        };
122
123        let tier = tier.unwrap_or_else(|| Tiers::LOW);
124
125        // Update database if never before initialized
126        if self.pidx().is_none() {
127            self.set_pidx(pidx)?;
128        }
129
130        if self.algo().is_none() {
131            self.set_algo(algo)?;
132        }
133
134        if self.salt().is_none() {
135            self.set_salt(salt)?;
136        }
137
138        if self.tier().is_none() {
139            self.set_tier(tier)?;
140        }
141
142        // Handle aeid initialization/update
143        if self.aeid().is_empty() {
144            self.update_aeid(aeid, self._seed.clone())?;
145        } else {
146            self.encrypter = Some(Encrypter::new(None, None, Some(&mut self.aeid()))?);
147
148            if self._seed.is_empty()
149                || !self.encrypter.as_ref().unwrap().verify_seed(&self._seed)?
150            {
151                return Err(KERIError::AuthError(format!(
152                    "Last seed missing or provided last seed not associated with last aeid={:?}.",
153                    self.aeid()
154                )));
155            }
156
157            self.decrypter = Some(Decrypter::new(Some(&self._seed), None, None)?);
158        }
159
160        self.inited = true;
161        Ok(())
162    }
163
164    /// Ingest secrecies as a list of lists of secrets organized in event order
165    /// to register the sets of secrets of associated externally generated keypair
166    /// lists into the database.
167    ///
168    /// Returns:
169    ///     (ipre, verferies) where:
170    ///         ipre is prefix index of ingested key pairs needed to fetch later for replay
171    ///         verferies is list of lists of all the verfers for the public keys
172    ///         from the private keys in secrecies in order of appearance.
173    ///
174    /// # Parameters
175    /// * `secrecies` - List of lists of fully qualified secrets (private keys)
176    /// * `iridx` - Initial ridx at which to set PubSit after ingestion
177    /// * `ncount` - Count of next public keys for next after end of secrecies
178    /// * `ncode` - Derivation code qb64 of all ncount next public keys after end of secrecies
179    /// * `dcode` - Derivation code qb64 of next digers after end of secrecies
180    /// * `algo` - Key creation algorithm code for next after end of secrecies
181    /// * `salt` - qb64 salt for randomization when salty algorithm used
182    /// * `stem` - Path modifier used with salt to derive private keys when using salty algorithms
183    /// * `tier` - Security criticality tier code when using salty algorithm
184    /// * `rooted` - True means derive incept salt from root salt when incept salt not provided
185    /// * `transferable` - True means each public key uses transferable derivation code
186    /// * `temp` - True is temporary for testing
187    pub fn ingest(
188        &mut self,
189        secrecies: Vec<Vec<String>>,
190        iridx: Option<usize>,
191        ncount: Option<usize>,
192        ncode: Option<&str>,
193        dcode: Option<&str>,
194        algo: Option<Algos>,
195        salt: Option<Vec<u8>>,
196        stem: Option<String>,
197        tier: Option<Tiers>,
198        rooted: Option<bool>,
199        transferable: Option<bool>,
200        temp: Option<bool>,
201    ) -> Result<(String, Vec<Vec<Verfer>>), KERIError> {
202        let iridx = iridx.unwrap_or(0);
203        let ncount = ncount.unwrap_or(1);
204        let ncode = ncode.unwrap_or(mtr_dex::ED25519_SEED);
205        let _dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
206        let algo = algo.unwrap_or(Algos::Salty);
207        let rooted = rooted.unwrap_or(true);
208        let transferable = transferable.unwrap_or(true);
209        let temp = temp.unwrap_or(false);
210
211        if iridx > secrecies.len() {
212            return Err(KERIError::ValueError(format!(
213                "Initial ridx={} beyond last secrecy.",
214                iridx
215            )));
216        }
217
218        // Configure parameters for creating new keys after ingested sequence
219        let salt = if rooted && salt.is_none() {
220            self.salt().unwrap_or_else(|| {
221                // Fallback to generating a new salt if none exists
222                Salter::new(None, None, None).unwrap().qb64b()
223            })
224        } else {
225            salt.unwrap_or_else(|| {
226                self.salt().unwrap_or_else(|| {
227                    // Fallback to generating a new salt if none exists
228                    Salter::new(None, None, None).unwrap().qb64b()
229                })
230            })
231        };
232
233        let tier = if rooted && tier.is_none() {
234            self.tier().unwrap_or(Tiers::LOW) // Use LOW as default fallback
235        } else {
236            tier.unwrap_or_else(|| {
237                self.tier().unwrap_or(Tiers::LOW) // Use LOW as default fallback
238            })
239        };
240
241        let pidx = self.pidx().unwrap_or(0);
242
243        // Create creator for generating new keys after ingested sequence
244        let creator = Creatory::new(algo);
245        let creator_instance = creator.make(
246            Some(&String::from_utf8_lossy(&salt)),
247            stem.as_deref(),
248            Some(tier.clone()),
249        )?;
250
251        let mut ipre = String::new();
252        let mut pubs = Vec::new();
253        let mut ridx = 0;
254        let mut kidx = 0;
255
256        let mut verferies: Vec<Vec<Verfer>> = Vec::new(); // list of lists of verfers
257        let mut first = true;
258        let mut secrecies = VecDeque::from(secrecies);
259
260        while let Some(csecrets) = secrecies.pop_front() {
261            // Create signers from current secrets
262            let mut csigners = Vec::new();
263            for secret in &csecrets {
264                let signer = Signer::new(
265                    Some(&base64::decode(secret).map_err(|e| {
266                        KERIError::ValueError(format!("Invalid base64 secret: {}", e))
267                    })?),
268                    None, // Use default code
269                    Some(transferable),
270                )?;
271                csigners.push(signer);
272            }
273
274            let csize = csigners.len();
275            verferies.push(csigners.iter().map(|s| s.verfer.clone()).collect());
276
277            if first {
278                // Secret to encrypt here
279                let pp = PrePrm {
280                    pidx,
281                    algo: format!("{:?}", algo).to_lowercase(),
282                    salt: if let Some(ref encrypter) = self.encrypter {
283                        encrypter.encrypt(Some(&salt), None, None)?.qb64()
284                    } else {
285                        String::from_utf8_lossy(&salt).to_string()
286                    },
287                    stem: stem.clone().unwrap_or_default(),
288                    tier: format!("{:?}", tier).to_lowercase(),
289                };
290
291                let pre = csigners[0].verfer.qb64b();
292                ipre = csigners[0].verfer.qb64();
293
294                let mut pre_copy = pre.clone();
295                let prefixer = Prefixer::from_qb64b(&mut pre_copy, None)?;
296
297                if !self.ks.pres.put(&[&pre], &prefixer)? {
298                    return Err(KERIError::ValueError(format!(
299                        "Already incepted pre={}.",
300                        String::from_utf8_lossy(&pre)
301                    )));
302                }
303
304                if !self.ks.prms.put(&[&pre], &pp)? {
305                    return Err(KERIError::ValueError(format!(
306                        "Already incepted prm for pre={}.",
307                        String::from_utf8_lossy(&pre)
308                    )));
309                }
310
311                self.set_pidx(pidx + 1)?; // increment so unique
312                first = false;
313            }
314
315            // Store secrets (private key val keyed by public key)
316            let pre = csigners[0].verfer.qb64b();
317            for signer in &csigners {
318                self.ks
319                    .pris
320                    .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
321            }
322
323            pubs = csigners.iter().map(|s| s.verfer.qb64()).collect();
324            let pub_set = PubSet { pubs: pubs.clone() };
325            self.ks.pubs.put(&[&ri_key(&pre, ridx)], &pub_set)?;
326
327            let dt = nowiso8601();
328            if ridx == iridx.saturating_sub(1).max(0) {
329                // setup ps.old at this ridx
330                let old = if iridx == 0 {
331                    Some(PubLot::default()) // defaults ok
332                } else {
333                    let osith = format!("{:x}", (csize / 2).max(1));
334                    let _ost =
335                        Tholder::new(None, None, Some(TholderSith::HexString(osith)))?.sith();
336                    Some(PubLot {
337                        pubs: pubs.clone(),
338                        ridx,
339                        kidx,
340                        dt: dt.clone(),
341                    })
342                };
343
344                let ps = PreSit {
345                    old,
346                    new: PubLot::default(), // .new and .nxt are default
347                    nxt: PubLot::default(),
348                };
349
350                if !self.ks.sits.pin(&[&pre], &ps)? {
351                    return Err(KERIError::ValueError(format!(
352                        "Problem updating pubsit db for pre={}.",
353                        String::from_utf8_lossy(&pre)
354                    )));
355                }
356            }
357
358            if ridx == iridx {
359                // setup ps.new at this ridx
360                let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
361                    KERIError::ValueError(format!(
362                        "Attempt to rotate nonexistent pre={}.",
363                        String::from_utf8_lossy(&pre)
364                    ))
365                })?;
366
367                let new = PubLot {
368                    pubs: pubs.clone(),
369                    ridx,
370                    kidx,
371                    dt: dt.clone(),
372                };
373                ps.new = new;
374
375                if !self.ks.sits.pin(&[&pre], &ps)? {
376                    return Err(KERIError::ValueError(format!(
377                        "Problem updating pubsit db for pre={}.",
378                        String::from_utf8_lossy(&pre)
379                    )));
380                }
381            }
382
383            if ridx == iridx + 1 {
384                // set up ps.nxt at this ridx
385                let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
386                    KERIError::ValueError(format!(
387                        "Attempt to rotate nonexistent pre={}.",
388                        String::from_utf8_lossy(&pre)
389                    ))
390                })?;
391
392                let nxt = PubLot {
393                    pubs: pubs.clone(),
394                    ridx,
395                    kidx,
396                    dt: dt.clone(),
397                };
398                ps.nxt = nxt;
399
400                if !self.ks.sits.pin(&[&pre], &ps)? {
401                    return Err(KERIError::ValueError(format!(
402                        "Problem updating pubsit db for pre={}.",
403                        String::from_utf8_lossy(&pre)
404                    )));
405                }
406            }
407
408            ridx += 1; // next ridx
409            kidx += csize; // next kidx
410        }
411
412        // create nxt signers after ingested signers
413        let nsigners = creator_instance.create(
414            None,
415            Some(ncount),
416            Some(ncode),
417            Some(pidx),
418            Some(ridx),
419            Some(kidx),
420            Some(transferable),
421            Some(temp),
422        );
423
424        // Get pre from the first ingested signer
425        let pre = if !verferies.is_empty() && !verferies[0].is_empty() {
426            verferies[0][0].qb64b()
427        } else {
428            return Err(KERIError::ValueError(
429                "No signers were ingested".to_string(),
430            ));
431        };
432
433        // store secrets (private key val keyed by public key)
434        for signer in &nsigners {
435            self.ks
436                .pris
437                .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
438        }
439
440        pubs = nsigners.iter().map(|s| s.verfer.qb64()).collect();
441        let pub_set = PubSet { pubs: pubs.clone() };
442        self.ks.pubs.put(&[&ri_key(&pre, ridx)], &pub_set)?;
443
444        if ridx == iridx + 1 {
445            // want to set up ps.next at this ridx
446            let dt = nowiso8601();
447            let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
448                KERIError::ValueError(format!(
449                    "Attempt to rotate nonexistent pre={}.",
450                    String::from_utf8_lossy(&pre)
451                ))
452            })?;
453
454            let nxt = PubLot {
455                pubs: pubs.clone(),
456                ridx,
457                kidx,
458                dt,
459            };
460            ps.nxt = nxt;
461
462            if !self.ks.sits.pin(&[&pre], &ps)? {
463                return Err(KERIError::ValueError(format!(
464                    "Problem updating pubsit db for pre={}.",
465                    String::from_utf8_lossy(&pre)
466                )));
467            }
468        }
469
470        Ok((ipre, verferies))
471    }
472
473    pub fn replay(
474        &mut self,
475        pre: &[u8],
476        dcode: Option<&str>,
477        advance: Option<bool>,
478        erase: Option<bool>,
479    ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
480        let dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
481        let advance = advance.unwrap_or(true);
482        let erase = erase.unwrap_or(true);
483
484        // Get prefix parameters
485        let pp = self.ks.prms.get(&[pre])?.ok_or_else(|| {
486            KERIError::ValueError(format!(
487                "Attempt to replay nonexistent pre={}.",
488                String::from_utf8_lossy(pre)
489            ))
490        })?;
491
492        // Get prefix situation
493        let mut ps = self.ks.sits.get(&[pre])?.ok_or_else(|| {
494            KERIError::ValueError(format!(
495                "Attempt to replay nonexistent pre={}.",
496                String::from_utf8_lossy(pre)
497            ))
498        })?;
499
500        // Declare old outside of the advance block so it's available later
501        let old_keys_to_erase = if advance {
502            // Save the old keys before updating
503            let old_keys = ps.old.clone();
504
505            ps.old = Some(ps.new.clone()); // move prior new to old so save previous one step
506            ps.new = ps.nxt.clone(); // move prior nxt to new which new is now current signer
507            let ridx = ps.new.ridx;
508            let kidx = ps.new.kidx;
509            let csize = ps.new.pubs.len();
510
511            // Usually when next keys are null then aid is effectively non-transferable
512            // but when replaying injected keys reaching null next pub keys or
513            // equivalently default empty is the sign that we have reached the
514            // end of the replay so need to raise an IndexError
515            let pubset = self
516                .ks
517                .pubs
518                .get(&[&ri_key(pre, ridx + 1)])?
519                .ok_or_else(|| {
520                    KERIError::IndexError(format!(
521                        "Invalid replay attempt of pre={} at ridx={}.",
522                        String::from_utf8_lossy(pre),
523                        ridx
524                    ))
525                })?;
526
527            let pubs = pubset.pubs.clone(); // create nxt from pubs
528            let dt = nowiso8601();
529            let nxt = PubLot {
530                pubs,
531                ridx: ridx + 1,
532                kidx: kidx + csize,
533                dt,
534            };
535            ps.nxt = nxt;
536
537            // Return the old keys to potentially erase later
538            old_keys
539        } else {
540            None
541        };
542
543        let mut verfers = Vec::new(); // assign verfers from current new was prior nxt
544        for pub_key in &ps.new.pubs {
545            if !self._seed.is_empty() && self.decrypter.is_none() {
546                return Err(KERIError::DecryptError(
547                    "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
548                ));
549            }
550
551            let signer = self
552                .ks
553                .pris
554                .get(&[pub_key.as_bytes()], self.decrypter.clone())?
555                .ok_or_else(|| {
556                    KERIError::ValueError(format!("Missing prikey in db for pubkey={}", pub_key))
557                })?;
558
559            verfers.push(signer.verfer);
560        }
561
562        // Create digers from next public keys
563        let mut digers = Vec::new();
564        for pub_key in &ps.nxt.pubs {
565            let diger = Diger::from_ser(pub_key.as_bytes(), Some(dcode))?;
566            digers.push(diger);
567        }
568
569        if advance {
570            if !self.ks.sits.pin(&[pre], &ps)? {
571                return Err(KERIError::ValueError(format!(
572                    "Problem updating pubsit db for pre={}.",
573                    String::from_utf8_lossy(pre)
574                )));
575            }
576
577            // Now we can use old_keys_to_erase since it's in scope
578            if erase {
579                if let Some(old) = old_keys_to_erase {
580                    for pub_key in &old.pubs {
581                        self.ks.pris.rem(&[pub_key.as_bytes()])?;
582                    }
583                }
584            }
585        }
586
587        Ok((verfers, digers))
588    }
589
590    /// Update the aeid (authentication and encryption identifier) and re-encrypt all secrets
591    ///
592    /// # Parameters
593    /// * `aeid` - qb64b of new auth encrypt id (public signing key)
594    ///            aeid may match current aeid (no change)
595    ///            aeid may be empty (unencrypts and removes aeid)
596    ///            aeid may be different and not empty (reencrypts)
597    /// * `seed` - qb64b of new seed from which new aeid is derived (private signing key seed)
598    ///
599    /// # Returns
600    /// * `Result<(), KERIError>` - Success or error
601    pub fn update_aeid(&mut self, aeid: Vec<u8>, seed: Vec<u8>) -> Result<(), KERIError> {
602        let current_aeid = self.aeid();
603
604        // Check that the last current seed matches the last current aeid
605        if !current_aeid.is_empty() {
606            if self._seed.is_empty()
607                || !self
608                    .encrypter
609                    .as_ref()
610                    .ok_or_else(|| {
611                        KERIError::AuthError("Current encrypter is missing".to_string())
612                    })?
613                    .verify_seed(&self._seed)?
614            {
615                return Err(KERIError::AuthError(format!(
616                    "Last seed missing or provided last seed not associated with last aeid={:?}.",
617                    current_aeid
618                )));
619            }
620        }
621
622        // Update encrypter based on new aeid
623        if !aeid.is_empty() {
624            if aeid != current_aeid {
625                // Changing to a new aeid, so update encrypter
626                let new_encrypter = Encrypter::new(None, None, Some(&aeid.clone()))?;
627
628                // Verify new seed belongs to new aeid
629                if seed.is_empty() || !new_encrypter.verify_seed(&seed)? {
630                    return Err(KERIError::AuthError(format!(
631                        "Seed missing or provided seed not associated with provided aeid={:?}.",
632                        aeid
633                    )));
634                }
635
636                self.encrypter = Some(new_encrypter);
637            }
638        } else {
639            // Changing to empty aeid, so new encrypter is None
640            self.encrypter = None;
641        }
642
643        // Re-encrypt all secrets with new encrypter
644
645        // Re-encrypt root salt secret
646        if let Some(salt) = self.salt() {
647            // Automatically decrypted on fetch
648            self.set_salt(salt)?;
649        }
650
651        // Re-encrypt other secrets if we have a decrypter
652        if let Some(decrypter) = &self.decrypter {
653            // Re-encrypt root salt secrets by prefix parameters in prms
654            let empty: [&[u8]; 0] = [];
655            for (keys, mut data) in self
656                .ks
657                .prms
658                .get_item_iter(&empty)
659                .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?
660            {
661                if !data.salt.is_empty() {
662                    // Decrypt the salt with current decrypter
663                    let salter_any = decrypter.decrypt(
664                        None,
665                        Some(&data.salt),
666                        None,
667                        Some(false),
668                        Some(false),
669                    )?;
670                    let salter = salter_any.downcast_ref::<Salter>().ok_or_else(|| {
671                        KERIError::ValueError("Failed to downcast to Salter".to_string())
672                    })?;
673
674                    // Re-encrypt with the new encrypter or store as is
675                    if let Some(encrypter) = &self.encrypter {
676                        let encrypted = encrypter.encrypt(None, Some(salter), None)?;
677                        data.salt = encrypted.qb64();
678                    } else {
679                        data.salt = salter.qb64();
680                    }
681
682                    // Update the database
683                    self.ks.prms.pin(&keys, &data).map_err(|e| {
684                        KERIError::ManagerError(format!("Failed to update aeid: {}", e))
685                    })?;
686                }
687            }
688
689            // Re-encrypt private signing key seeds
690            // For each signer in the pris database
691            let empty: [&[u8]; 0] = [];
692            for (keys, signer) in self
693                .ks
694                .pris
695                .get_item_iter(&empty, false, Some(decrypter.clone()))
696                .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?
697            {
698                // Pin the signer with the new encrypter
699                self.ks
700                    .pris
701                    .pin(&keys, &signer, self.encrypter.clone())
702                    .map_err(|e| {
703                        KERIError::ManagerError(format!("Failed to update aeid: {}", e))
704                    })?;
705            }
706        }
707
708        // Update aeid in database
709        self.ks
710            .gbls
711            .pin(&["aeid"], &aeid)
712            .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?;
713
714        // Update seed in memory
715        self._seed = seed.clone();
716
717        // Update decrypter
718        if !seed.is_empty() {
719            self.decrypter = Some(Decrypter::new(None, None, Some(&seed))?);
720        } else {
721            self.decrypter = None;
722        }
723
724        Ok(())
725    }
726
727    /// Get the aeid (authentication and encryption identifier)
728    ///
729    /// # Returns
730    /// * String - The aeid value
731    pub fn aeid(&self) -> Vec<u8> {
732        match self.ks.gbls.get(&["aeid"]) {
733            Ok(Some(bytes)) => bytes,
734            _ => Vec::new(),
735        }
736    }
737
738    /// Get the pidx (prefix index)
739    ///
740    /// # Returns
741    /// * Option<usize> - The pidx value if it exists
742    pub fn pidx(&self) -> Option<usize> {
743        match self.ks.gbls.get(&["pidx"]) {
744            Ok(Some(bytes)) => {
745                let s = String::from_utf8(bytes).unwrap_or_default();
746                s.parse::<usize>().ok()
747            }
748            _ => None,
749        }
750    }
751
752    /// Set the pidx (prefix index)
753    ///
754    /// # Parameters
755    /// * `value` - New pidx value
756    ///
757    /// # Returns
758    /// * `Result<(), DBError>` - Success or error
759    pub fn set_pidx(&self, value: usize) -> Result<(), KERIError> {
760        self.ks
761            .gbls
762            .pin(&["pidx"], &value.to_string().as_bytes())
763            .map_err(|e| KERIError::ManagerError(format!("Failed to set pidx: {}", e)))?;
764        Ok(())
765    }
766
767    /// Get the algo (algorithm)
768    ///
769    /// # Returns
770    /// * Option<String> - The algo value if it exists
771    pub fn algo(&self) -> Option<String> {
772        match self.ks.gbls.get(&["algo"]) {
773            Ok(Some(bytes)) => Some(String::from_utf8(bytes).unwrap_or_default()),
774            _ => None,
775        }
776    }
777
778    /// Set the algo (algorithm)
779    ///
780    /// # Parameters
781    /// * `value` - New algo value
782    ///
783    /// # Returns
784    /// * `Result<(), DBError>` - Success or error
785    pub fn set_algo(&self, value: Algos) -> Result<(), KERIError> {
786        self.ks
787            .gbls
788            .pin(&["algo"], &value.to_string().as_bytes())
789            .map_err(|e| KERIError::ManagerError(format!("Failed to set algo: {}", e)))?;
790        Ok(())
791    }
792
793    /// Get the salt
794    ///
795    /// # Returns
796    /// * Option<String> - The salt value if it exists
797    pub fn salt(&self) -> Option<Vec<u8>> {
798        match self.ks.gbls.get(&["salt"]) {
799            Ok(Some(bytes)) => match self.decrypter {
800                Some(_) => {
801                    let st = String::from_utf8(bytes);
802                    let salter = self
803                        .decrypter
804                        .clone()?
805                        .decrypt(None, Some(st.unwrap().as_str()), None, None, None)
806                        .unwrap();
807                    let salter = salter.downcast_ref::<Salter>().unwrap();
808                    Some(salter.qb64b())
809                }
810                None => Some(bytes),
811            },
812            _ => None,
813        }
814    }
815
816    /// Set the salt
817    ///
818    /// # Parameters
819    /// * `value` - New salt value
820    ///
821    /// # Returns
822    /// * `Result<(), KERIError>` - Success or error
823    pub fn set_salt(&self, value: Vec<u8>) -> Result<(), KERIError> {
824        if let Some(encrypter) = &self.encrypter {
825            // Re-encrypt salt with new encrypter
826            let encrypted_salt =
827                encrypter.encrypt(Some(&value), None, Some(mtr_dex::X25519_CIPHER_SALT))?;
828            self.ks
829                .gbls
830                .pin(&["salt"], &encrypted_salt.qb64b())
831                .map_err(|e| KERIError::ManagerError(format!("Failed to set salt: {}", e)))?;
832        } else {
833            self.ks
834                .gbls
835                .pin(&["salt"], &value)
836                .map_err(|e| KERIError::ManagerError(format!("Failed to set salt: {}", e)))?;
837        }
838
839        Ok(())
840    }
841
842    /// Get the tier
843    ///
844    /// # Returns
845    /// * Option<String> - The tier value if it exists
846    pub fn tier(&self) -> Option<Tiers> {
847        match self.ks.gbls.get(&["tier"]) {
848            Ok(Some(bytes)) => Some(Tiers::from(
849                String::from_utf8(bytes).unwrap_or_default().as_str(),
850            )),
851            _ => None,
852        }
853    }
854
855    /// Set the tier
856    ///
857    /// # Parameters
858    /// * `value` - New tier value
859    ///
860    /// # Returns
861    /// * `Result<(), DBError>` - Success or error
862    pub fn set_tier(&self, value: Tiers) -> Result<(), KERIError> {
863        self.ks
864            .gbls
865            .put(&["tier"], &value.to_string().as_bytes())
866            .map_err(|e| KERIError::ManagerError(format!("Failed to set tier: {}", e)))?;
867        Ok(())
868    }
869
870    /// Get the seed
871    ///
872    /// # Returns
873    /// * String - The seed value
874    pub fn seed(&self) -> &Vec<u8> {
875        &self._seed
876    }
877
878    /// Incept a prefix with key parameters
879    ///
880    /// # Parameters
881    /// * `icodes` - Optional list of private key derivation codes qb64 str, one per incepting key pair
882    /// * `icount` - Count of incepting public keys when icodes not provided
883    /// * `icode` - Derivation code of all icount incepting private keys when icodes list not provided
884    /// * `ncodes` - Optional list of private key derivation codes qb64 str, one per next key pair
885    /// * `ncount` - Count of next public keys when ncodes not provided
886    /// * `ncode` - Derivation code of all ncount next private keys when ncodes list not provided
887    /// * `dcode` - Derivation code of next digesters. Default is Blake3_256
888    /// * `algo` - Optional key creation algorithm code
889    /// * `salt` - Optional qb64 salt for randomization when salty algorithm used
890    /// * `stem` - Optional path modifier used with salt to derive private keys when using salty algorithm
891    /// * `tier` - Optional security criticality tier code when using salty algorithm
892    /// * `rooted` - Whether to derive incept salt from root salt when incept salt not provided
893    /// * `transferable` - Whether each public key uses transferable derivation code
894    /// * `temp` - Whether the inception is temporary for testing, modifies tier of salty algorithm
895    ///
896    /// # Returns
897    /// * `Result<(Vec<Verfer>, Vec<Diger>), KERIError>` - Tuple containing:
898    ///   - Vector of current public key verfers
899    ///   - Vector of next public key digesters
900    pub fn incept(
901        &mut self,
902        icodes: Option<Vec<&str>>,
903        icount: Option<usize>,
904        icode: Option<&str>,
905        ncodes: Option<Vec<&str>>,
906        ncount: Option<usize>,
907        ncode: Option<&str>,
908        dcode: Option<String>,
909        algo: Option<Algos>,
910        salt: Option<Vec<u8>>,
911        stem: Option<&str>,
912        tier: Option<Tiers>,
913        rooted: Option<bool>,
914        transferable: Option<bool>,
915        temp: Option<bool>,
916    ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
917        // Set default values
918        let rooted = rooted.unwrap_or(true);
919        let transferable = transferable.unwrap_or(true);
920        let temp = temp.unwrap_or(false);
921        let icount = icount.unwrap_or(1);
922        let ncount = ncount.unwrap_or(1);
923        let icode = icode.unwrap_or_else(|| mtr_dex::ED25519_SEED);
924        let ncode = ncode.unwrap_or_else(|| mtr_dex::ED25519_SEED);
925        let _dcode = dcode.unwrap_or_else(|| mtr_dex::BLAKE3_256.to_string());
926
927        // Get root defaults to initialize key sequence
928        let algo = if rooted && algo.is_none() {
929            // Use root algo from db as default
930            Algos::from_str(&self.algo().ok_or_else(|| {
931                KERIError::ValueError("Root algorithm not found in database".to_string())
932            })?)?
933        } else {
934            algo.unwrap_or(Algos::Salty)
935        };
936
937        let salt = if rooted && salt.is_none() {
938            // Use root salt from db instead of random salt
939            self.salt().ok_or_else(|| {
940                KERIError::ValueError("Root salt not found in database".to_string())
941            })?
942        } else {
943            salt.unwrap_or_else(|| Vec::new())
944        };
945
946        let tier = if rooted && tier.is_none() {
947            // Use root tier from db as default
948            &self.tier()
949        } else {
950            &Some(tier.unwrap_or(Tiers::LOW))
951        };
952
953        // Get next pidx
954        let pidx = self.pidx().ok_or_else(|| {
955            KERIError::ValueError("Prefix index not found in database".to_string())
956        })?;
957        let ridx = 0; // rotation index
958        let kidx = 0; // key pair index
959
960        // Create the key creator
961        let creator = Creatory::new(algo).make(
962            Some(String::from_utf8(salt).unwrap().as_str()),
963            stem.clone(),
964            tier.clone(),
965        )?;
966
967        // Create initial signers
968        let icodes = if let Some(ic) = icodes {
969            ic
970        } else {
971            // Create a vector of the same code with length icount
972            (0..icount).map(|_| icode).collect()
973        };
974
975        let icode_count = icodes.len();
976        let isigners = creator.create(
977            Some(icodes),
978            None,
979            None,
980            Some(pidx),
981            Some(ridx),
982            Some(kidx),
983            Some(transferable),
984            Some(temp),
985        );
986
987        let verfers: Vec<Verfer> = isigners.iter().map(|s| s.verfer.clone()).collect();
988
989        // Create next signers
990        let ncodes = if let Some(nc) = ncodes {
991            nc
992        } else {
993            // Create a vector of the same code with length ncount
994            (0..ncount).map(|_| ncode).collect()
995        };
996
997        let nsigners = creator.create(
998            Some(ncodes),
999            Some(0), // count set to 0 to ensure does not create signers if ncodes is empty
1000            None,
1001            Some(pidx),
1002            Some(ridx + 1),
1003            Some(kidx + icode_count),
1004            Some(transferable),
1005            Some(temp),
1006        );
1007
1008        // Create digesters for next keys
1009        let digers: Vec<Diger> = nsigners
1010            .iter()
1011            .map(|signer| -> Result<Diger, KERIError> {
1012                Diger::from_ser(&mut signer.verfer.qb64b(), None)
1013                    .map_err(|e| KERIError::MatterError(e.to_string()))
1014            })
1015            .collect::<Result<Vec<Diger>, KERIError>>()?;
1016
1017        let tier_str = match creator.tier() {
1018            None => "",
1019            Some(tier) => &tier.to_string(),
1020        };
1021        // Create prefix parameters
1022        let mut pp = PrePrm {
1023            pidx,
1024            algo: algo.to_string(),
1025            stem: creator.stem().clone(),
1026            tier: tier_str.to_string(),
1027            salt: String::new(),
1028        };
1029
1030        if !creator.salt().is_empty() {
1031            if let Some(encrypter) = &self.encrypter {
1032                // Encrypt the salt
1033                let cipher = encrypter.encrypt(
1034                    Some(&creator.salt().as_bytes().to_vec()),
1035                    None,
1036                    Some(mtr_dex::X25519_CIPHER_SALT),
1037                )?;
1038                pp.salt = cipher.qb64();
1039            } else {
1040                // Store salt unencrypted
1041                pp.salt = String::from_utf8_lossy(&creator.salt().as_bytes().to_vec()).to_string();
1042            }
1043        }
1044
1045        // Get current datetime
1046
1047        let dt = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
1048
1049        // Create prefix situation
1050        let ps = PreSit {
1051            old: None,
1052            new: PubLot {
1053                pubs: verfers.iter().map(|v| v.qb64()).collect(),
1054                ridx,
1055                kidx,
1056                dt: dt.clone(),
1057            },
1058            nxt: PubLot {
1059                pubs: nsigners.iter().map(|s| s.verfer.qb64()).collect(),
1060                ridx: ridx + 1,
1061                kidx: kidx + icode_count,
1062                dt,
1063            },
1064        };
1065
1066        // Use first public key as temporary prefix
1067        let pre = verfers[0].qb64b();
1068
1069        // Check if prefix already exists
1070        let pre_exists = self.ks.pres.get(&[&pre])?;
1071        if pre_exists.is_some() {
1072            return Err(KERIError::ValueError(format!(
1073                "Already incepted pre={}.",
1074                String::from_utf8_lossy(&pre)
1075            )));
1076        }
1077
1078        // Store the prefix
1079        let prefixer = Prefixer::from_qb64b(&mut pre.clone(), None)?;
1080        self.ks
1081            .pres
1082            .put(&[&pre], &prefixer)
1083            .map_err(|e| KERIError::ManagerError(format!("Failed to update pres: {}", e)))?;
1084
1085        // Store the parameters
1086        if !self.ks.prms.put(&[&pre], &pp)? {
1087            return Err(KERIError::ValueError(format!(
1088                "Already incepted prm for pre={}.",
1089                String::from_utf8_lossy(&pre)
1090            )));
1091        }
1092
1093        // Increment the pidx for next inception
1094        self.set_pidx(pidx + 1)?;
1095
1096        // Store the situation
1097        if !self.ks.sits.put(&[&pre], &ps)? {
1098            return Err(KERIError::ValueError(format!(
1099                "Already incepted sit for pre={}.",
1100                String::from_utf8_lossy(&pre)
1101            )));
1102        }
1103
1104        // Store initial signers (private keys) keyed by public keys
1105        for signer in isigners {
1106            self.ks
1107                .pris
1108                .put(&[&signer.verfer.qb64b()], &signer, self.encrypter.clone())
1109                .map_err(|e| KERIError::ManagerError(format!("Failed to put pris: {}", e)))?;
1110        }
1111
1112        // Store public keys for initial rotation
1113        self.ks
1114            .pubs
1115            .put(
1116                &[&Keeper::ri_key(
1117                    String::from_utf8(pre.clone()).unwrap().as_str(),
1118                    ridx as u64,
1119                )],
1120                &PubSet { pubs: ps.new.pubs },
1121            )
1122            .map_err(|e| KERIError::ManagerError(format!("Failed to update pubs: {}", e)))?;
1123
1124        // Store next signers
1125        for signer in nsigners {
1126            self.ks
1127                .pris
1128                .put(&[&signer.verfer.qb64b()], &signer, self.encrypter.clone())
1129                .map_err(|e| KERIError::ManagerError(format!("Failed to put pris: {}", e)))?;
1130        }
1131
1132        // Store public keys for next rotation
1133        self.ks
1134            .pubs
1135            .put(
1136                &[&Keeper::ri_key(
1137                    String::from_utf8(pre).unwrap().as_str(),
1138                    (ridx + 1) as u64,
1139                )],
1140                &PubSet { pubs: ps.nxt.pubs },
1141            )
1142            .map_err(|e| KERIError::ManagerError(format!("Failed to put pubs: {}", e)))?;
1143
1144        Ok((verfers, digers))
1145    }
1146
1147    pub fn move_prefix(&self, old: &[u8], new: &[u8]) -> Result<(), KERIError> {
1148        // If old and new are the same, nothing to do
1149        if old == new {
1150            return Ok(());
1151        }
1152
1153        // Check if old prefix exists
1154        let old_pre = self.ks.pres.get(&[old])?;
1155        if old_pre.is_none() {
1156            return Err(KERIError::ValueError(format!(
1157                "Nonexistent old pre={}, nothing to assign.",
1158                String::from_utf8_lossy(old)
1159            )));
1160        }
1161
1162        // Check if new prefix already exists (to avoid clobbering)
1163        let new_pre = self.ks.pres.get(&[new])?;
1164        if new_pre.is_some() {
1165            return Err(KERIError::ValueError(format!(
1166                "Preexistent new pre={} may not clobber.",
1167                String::from_utf8_lossy(new)
1168            )));
1169        }
1170
1171        // Get old PrePrm
1172        let old_prm = self.ks.prms.get(&[old])?;
1173        if old_prm.is_none() {
1174            return Err(KERIError::ValueError(format!(
1175                "Nonexistent old prm for pre={}, nothing to move.",
1176                String::from_utf8_lossy(old)
1177            )));
1178        }
1179        let old_prm = old_prm.unwrap();
1180
1181        // Check if new PrePrm already exists
1182        let new_prm = self.ks.prms.get(&[new])?;
1183        if new_prm.is_some() {
1184            return Err(KERIError::ValueError(format!(
1185                "Preexistent new prm for pre={} may not clobber.",
1186                String::from_utf8_lossy(new)
1187            )));
1188        }
1189
1190        // Get old PreSit
1191        let old_sit = self.ks.sits.get(&[old])?;
1192        if old_sit.is_none() {
1193            return Err(KERIError::ValueError(format!(
1194                "Nonexistent old sit for pre={}, nothing to move.",
1195                String::from_utf8_lossy(old)
1196            )));
1197        }
1198        let old_sit = old_sit.unwrap();
1199
1200        // Check if new PreSit already exists
1201        let new_sit = self.ks.sits.get(&[new])?;
1202        if new_sit.is_some() {
1203            return Err(KERIError::ValueError(format!(
1204                "Preexistent new sit for pre={} may not clobber.",
1205                String::from_utf8_lossy(new)
1206            )));
1207        }
1208
1209        // Move PrePrm
1210        if !self.ks.prms.put(&[new], &old_prm)? {
1211            return Err(KERIError::ValueError(format!(
1212                "Failed moving prm from old pre={} to new pre={}.",
1213                String::from_utf8_lossy(old),
1214                String::from_utf8_lossy(new)
1215            )));
1216        } else {
1217            self.ks.prms.rem(&[old])?;
1218        }
1219
1220        // Move PreSit
1221        if !self.ks.sits.put(&[new], &old_sit)? {
1222            return Err(KERIError::ValueError(format!(
1223                "Failed moving sit from old pre={} to new pre={}.",
1224                String::from_utf8_lossy(old),
1225                String::from_utf8_lossy(new)
1226            )));
1227        } else {
1228            self.ks.sits.rem(&[old])?;
1229        }
1230
1231        // Move .pubs entries if any
1232        let mut i: u64 = 0;
1233        let old_str = String::from_utf8_lossy(old).to_string();
1234        let new_str = String::from_utf8_lossy(new).to_string();
1235
1236        while let Some(pl) = self.ks.pubs.get(&[&Keeper::ri_key(&old_str, i)])? {
1237            if !self.ks.pubs.put(&[&Keeper::ri_key(&new_str, i)], &pl)? {
1238                return Err(KERIError::ValueError(format!(
1239                    "Failed moving pubs at pre={} ri={} to new pre={}",
1240                    old_str, i, new_str
1241                )));
1242            }
1243            // Remove the old pubkey entry
1244            self.ks.pubs.rem(&[&Keeper::ri_key(&old_str, i)])?;
1245            i += 1;
1246        }
1247
1248        // Create a Prefixer from the new prefix
1249        let mut new_copy = new.to_vec();
1250        let new_prefixer = Prefixer::from_qb64b(&mut new_copy, None)?;
1251
1252        // Assign old (replace with new prefixer)
1253        if !self.ks.pres.pin(&[old], &new_prefixer)? {
1254            return Err(KERIError::ValueError(format!(
1255                "Failed assigning new pre={} to old pre={}.",
1256                String::from_utf8_lossy(new),
1257                String::from_utf8_lossy(old)
1258            )));
1259        }
1260
1261        // Make new entry to reserve prefix
1262        if !self.ks.pres.put(&[new], &new_prefixer)? {
1263            return Err(KERIError::ValueError(format!(
1264                "Failed assigning new pre={}.",
1265                String::from_utf8_lossy(new)
1266            )));
1267        }
1268
1269        Ok(())
1270    }
1271
1272    /// Rotates keys for a prefix and returns tuple of verfers and digers
1273    ///
1274    /// Returns tuple (verfers, digers) for rotation event of keys for pre where
1275    /// verfers is list of current public key verfers
1276    /// public key is verfer.qb64
1277    /// digers is list of next public key digers
1278    /// digest to xor is diger.raw
1279    ///
1280    /// Rotates a prefix.
1281    /// Store the updated dictified PreSit in the keeper under pre
1282    ///
1283    /// # Parameters
1284    /// * `pre` - qb64b of prefix to rotate
1285    /// * `ncodes` - Optional list of private key derivation codes (qb64 string refs)
1286    ///   one per next key pair
1287    /// * `ncount` - Count of next public keys when ncodes not provided
1288    /// * `ncode` - Derivation code qb64 of all ncount next private keys
1289    ///   when ncodes not provided
1290    /// * `dcode` - Derivation code qb64 of next key digest of digers
1291    ///   Default is mtr_dex::BLAKE3_256
1292    /// * `transferable` - True means each public key uses transferable derivation code
1293    ///   Default is transferable. Special case is non-transferable.
1294    ///   Normally no use case for rotation to use transferable = False.
1295    ///   When the derivation process of the identifier prefix is
1296    ///   transferable then one should not use transferable = False for the
1297    ///   associated public key(s).
1298    /// * `temp` - True is temporary for testing. It modifies tier of salty algorithm
1299    /// * `erase` - True means erase old private keys made stale by rotation
1300    ///
1301    /// When both ncodes is empty and ncount is 0 then the nxt is null and will
1302    /// not be rotatable. This makes the identifier non-transferable in effect
1303    /// even when the identifier prefix is transferable.
1304    ///
1305    /// # Returns
1306    /// * `Result<(Vec<Verfer>, Vec<Diger>), KERIError>` - Tuple containing:
1307    ///   - Vector of current public key verfers
1308    ///   - Vector of next public key digers
1309    pub fn rotate(
1310        &self,
1311        pre: &[u8],
1312        ncodes: Option<Vec<&str>>,
1313        ncount: Option<usize>,
1314        ncode: Option<&str>,
1315        dcode: Option<&str>,
1316        transferable: Option<bool>,
1317        temp: Option<bool>,
1318        erase: Option<bool>,
1319    ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
1320        // Set default values
1321        let ncount = ncount.unwrap_or(1);
1322        let ncode = ncode.unwrap_or(mtr_dex::ED25519_SEED);
1323        let _dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
1324        let transferable = transferable.unwrap_or(true);
1325        let temp = temp.unwrap_or(false);
1326        let erase = erase.unwrap_or(true);
1327
1328        // Get prefix parameters from database
1329        let pp = match self.ks.prms.get(&[pre])? {
1330            Some(pp) => pp,
1331            None => {
1332                return Err(KERIError::ValueError(format!(
1333                    "Attempt to rotate nonexistent pre={}.",
1334                    String::from_utf8_lossy(pre)
1335                )))
1336            }
1337        };
1338
1339        // Get prefix situation from database
1340        let mut ps = match self.ks.sits.get(&[pre])? {
1341            Some(ps) => ps,
1342            None => {
1343                return Err(KERIError::ValueError(format!(
1344                    "Attempt to rotate nonexistent pre={}.",
1345                    String::from_utf8_lossy(pre)
1346                )))
1347            }
1348        };
1349
1350        // Check if the prefix is transferable (has next public keys)
1351        if ps.nxt.pubs.is_empty() {
1352            return Err(KERIError::ValueError(format!(
1353                "Attempt to rotate nontransferable pre={}.",
1354                String::from_utf8_lossy(pre)
1355            )));
1356        }
1357
1358        // Save the old keys for potential cleanup
1359        let old = ps.old.clone();
1360
1361        // Move prior new to old so save previous one step
1362        ps.old = Some(ps.new.clone());
1363
1364        // Move prior nxt to new which is now current signer
1365        ps.new = ps.nxt.clone();
1366
1367        // Assign verfers from current new (was prior nxt)
1368        let mut verfers = Vec::new();
1369        for pub_key in &ps.new.pubs {
1370            // Check for encryption/decryption authorization
1371            if self.encrypter.is_some() && self.decrypter.is_none() {
1372                return Err(KERIError::AuthError(
1373                    "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1374                ));
1375            }
1376
1377            // Get the signer from the database
1378            let signer = match self
1379                .ks
1380                .pris
1381                .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1382            {
1383                Some(signer) => signer,
1384                None => {
1385                    return Err(KERIError::ValueError(format!(
1386                        "Missing prikey in db for pubkey={}",
1387                        pub_key
1388                    )))
1389                }
1390            };
1391
1392            verfers.push(signer.verfer);
1393        }
1394
1395        // Process salt - decrypt if necessary
1396        let salt = if !pp.salt.is_empty() {
1397            if self.encrypter.is_some() {
1398                // We need to decrypt the salt
1399                if self.decrypter.is_none() {
1400                    return Err(KERIError::AuthError(
1401                        "Unauthorized decryption. Aeid but no decrypter.".to_string(),
1402                    ));
1403                }
1404
1405                // Decrypt the salt
1406                let salter_any = self.decrypter.as_ref().unwrap().decrypt(
1407                    None,
1408                    Some(&pp.salt),
1409                    None,
1410                    None,
1411                    None,
1412                )?;
1413
1414                let salter = salter_any.downcast_ref::<Salter>().ok_or_else(|| {
1415                    KERIError::ValueError("Failed to downcast to Salter".to_string())
1416                })?;
1417
1418                salter.qb64()
1419            } else {
1420                // Salt is not encrypted, just ensure it's valid
1421                let mut salt_bytes = pp.salt.as_bytes().to_vec();
1422                let salter = Salter::from_qb64b(&mut salt_bytes, None)?;
1423                salter.qb64()
1424            }
1425        } else {
1426            String::new()
1427        };
1428
1429        // Create key creator
1430        let creator = Creatory::new(Algos::from_str(&pp.algo)?).make(
1431            Some(&salt),
1432            Some(&pp.stem),
1433            Some(Tiers::from(pp.tier.as_str())),
1434        )?;
1435
1436        // Process ncodes
1437        let ncodes_to_use = if let Some(codes) = ncodes {
1438            codes
1439        } else {
1440            // Create vector with ncount copies of ncode
1441            vec![ncode; ncount]
1442        };
1443
1444        // Set up parameters for creating next keys
1445        let pidx = pp.pidx;
1446        let ridx = ps.new.ridx + 1;
1447        let kidx = ps.nxt.kidx + ps.new.pubs.len();
1448
1449        // Create next signers
1450        // Count set to 0 to ensure does not create signers if codes is empty
1451        let signers = creator.create(
1452            Some(ncodes_to_use),
1453            Some(0),
1454            None,
1455            Some(pidx),
1456            Some(ridx),
1457            Some(kidx),
1458            Some(transferable),
1459            Some(temp),
1460        );
1461
1462        // Create digesters for next keys
1463        let digers = signers
1464            .iter()
1465            .map(|signer| -> Result<Diger, KERIError> {
1466                Diger::from_ser(&mut signer.verfer.qb64b(), None)
1467                    .map_err(|e| KERIError::MatterError(e.to_string()))
1468            })
1469            .collect::<Result<Vec<Diger>, KERIError>>()?;
1470
1471        // Create the new next key set with current timestamp
1472        let dt = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
1473        ps.nxt = PubLot {
1474            pubs: signers.iter().map(|signer| signer.verfer.qb64()).collect(),
1475            ridx,
1476            kidx,
1477            dt,
1478        };
1479
1480        // Update the prefix situation in the database
1481        if !self.ks.sits.pin(&[pre], &ps)? {
1482            return Err(KERIError::ValueError(format!(
1483                "Problem updating pubsit db for pre={}.",
1484                String::from_utf8_lossy(pre)
1485            )));
1486        }
1487
1488        // Store the new signers' private keys
1489        for signer in &signers {
1490            self.ks
1491                .pris
1492                .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
1493        }
1494
1495        // Store public keys for lookup by rotation index
1496        let pre_str = String::from_utf8_lossy(pre).to_string();
1497        self.ks.pubs.put(
1498            &[&Keeper::ri_key(&pre_str, ps.nxt.ridx as u64)],
1499            &PubSet { pubs: ps.nxt.pubs },
1500        )?;
1501
1502        // Erase old private keys if requested
1503        if erase && old.is_some() {
1504            if let Some(old_keys) = old {
1505                for pub_key in old_keys.pubs {
1506                    self.ks.pris.rem(&[pub_key.as_bytes()])?;
1507                }
1508            }
1509        }
1510
1511        Ok((verfers, digers))
1512    }
1513
1514    /// Signs serialized data using private keys looked up from public keys
1515    ///
1516    /// # Parameters
1517    /// * `ser` - Serialized data to sign
1518    /// * `pubs` - Optional list of qb64 public keys to lookup private keys
1519    ///   one of pubs or verfers is required. If both then verfers is ignored.
1520    /// * `verfers` - Optional list of Verfer instances of public keys
1521    ///   one of pubs or verfers is required. If both then verfers is ignored.
1522    ///   If not pubs then gets public key from verfer.qb64
1523    /// * `indexed` - True means use indexed signatures and return list of Siger instances.
1524    ///   False means do not use indexed signatures and return list of Cigar instances
1525    /// * `indices` - Optional list of indices (offsets) when indexed == true,
1526    ///   to use for indexed signatures whose offset into the current keys
1527    ///   or prior next list may differ from the order of appearance
1528    ///   in the provided coherent pubs, verfers, signers lists.
1529    /// * `ondices` - Optional list of other indices (offsets) when indexed is true
1530    ///   for indexed signatures whose offset into the prior next list may differ
1531    ///   from the order of appearance in the provided coherent lists.
1532    /// * `pre` - Optional identity prefix (aid) of signer. Used for HDK salty
1533    ///   algo key lookup or re-creation.
1534    /// * `path` - Optional HDX randy algo signing key path tuple part
1535    ///
1536    /// # Returns
1537    /// * `Result<Vec<Siger>, KERIError>` - List of Siger instances if indexed is true
1538    /// * `Result<Vec<Cigar>, KERIError>` - List of Cigar instances if indexed is false
1539    ///
1540    /// # Notes
1541    /// When indexed, each index is an offset that maps the offset
1542    /// in the coherent lists onto the appropriate offset into
1543    /// the signing keys or prior next keys lists of a key event.
1544    pub fn sign(
1545        &self,
1546        ser: &[u8],
1547        pubs: Option<Vec<String>>,
1548        verfers: Option<Vec<Verfer>>,
1549        indexed: Option<bool>,
1550        indices: Option<Vec<u32>>,
1551        ondices: Option<Vec<Option<u32>>>,
1552        pre: Option<&[u8]>,
1553        _path: Option<(usize, usize)>,
1554    ) -> Result<Vec<Sigmat>, KERIError> {
1555        // Set default values
1556        let indexed = indexed.unwrap_or(true);
1557
1558        let mut signers = Vec::new();
1559
1560        // Handle case when both pubs and verfers are None
1561        if pubs.is_none() && verfers.is_none() {
1562            if pre.is_none() {
1563                return Err(KERIError::ValueError(
1564                    "pubs or verfers or pre required".to_string(),
1565                ));
1566            }
1567
1568            // Logic for generating signers from pre and path would go here
1569            // This part of the Python code is marked as placeholders/TODOs
1570            // For now, we'll leave this as unimplemented
1571            unimplemented!()
1572        }
1573
1574        // Process pubs if provided
1575        if let Some(pub_keys) = pubs {
1576            for pub_key in pub_keys {
1577                // Check if we need decryption but don't have a decrypter
1578                if self.encrypter.is_some() && self.decrypter.is_none() {
1579                    return Err(KERIError::AuthError(
1580                        "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1581                    ));
1582                }
1583
1584                // Get the signer from private keys database
1585                let signer = self
1586                    .ks
1587                    .pris
1588                    .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1589                    .ok_or_else(|| {
1590                        KERIError::ValueError(format!(
1591                            "Missing prikey in db for pubkey={}",
1592                            pub_key
1593                        ))
1594                    })?;
1595
1596                signers.push(signer);
1597            }
1598        }
1599        // Process verfers if provided and pubs was not provided
1600        else if let Some(verfer_list) = verfers {
1601            for verfer in verfer_list {
1602                // Check if we need decryption but don't have a decrypter
1603                if self.encrypter.is_some() && self.decrypter.is_none() {
1604                    return Err(KERIError::AuthError(
1605                        "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1606                    ));
1607                }
1608
1609                // Get the signer from private keys database
1610                let signer = self
1611                    .ks
1612                    .pris
1613                    .get(&[verfer.qb64b().as_slice()], self.decrypter.clone())?
1614                    .ok_or_else(|| {
1615                        KERIError::ValueError(format!(
1616                            "Missing prikey in db for pubkey={}",
1617                            verfer.qb64()
1618                        ))
1619                    })?;
1620
1621                signers.push(signer);
1622            }
1623        }
1624
1625        // Validate indices length if provided
1626        if let Some(ref idx) = indices {
1627            if idx.len() != signers.len() {
1628                return Err(KERIError::ValueError(format!(
1629                    "Mismatch indices length={} and resultant signers length={}",
1630                    idx.len(),
1631                    signers.len()
1632                )));
1633            }
1634        }
1635
1636        // Validate ondices length if provided
1637        if let Some(ref odx) = ondices {
1638            if odx.len() != signers.len() {
1639                return Err(KERIError::ValueError(format!(
1640                    "Mismatch ondices length={} and resultant signers length={}",
1641                    odx.len(),
1642                    signers.len()
1643                )));
1644            }
1645        }
1646
1647        // Create signatures based on indexed flag
1648        if indexed {
1649            let mut sigers = Vec::with_capacity(signers.len());
1650
1651            for j in 0..signers.len() {
1652                // Determine index value
1653                let i = if let Some(ref idx) = indices {
1654                    // Use provided index
1655                    idx[j]
1656                } else {
1657                    // Default to position in signers list
1658                    j as u32
1659                };
1660
1661                // Determine ondex value
1662                let o = if let Some(ref odx) = ondices {
1663                    // Use provided ondex
1664                    odx[j]
1665                } else {
1666                    // Default to None (no ondex)
1667                    Some(i)
1668                };
1669
1670                // Create siger with appropriate parameters
1671                let siger = signers[j].sign(
1672                    ser,
1673                    Some(i),
1674                    Some(o.is_none()), // only = true if o is None
1675                    o,
1676                )?;
1677
1678                sigers.push(siger);
1679            }
1680
1681            Ok(sigers)
1682        } else {
1683            // For non-indexed signatures, create cigars
1684            let mut cigars = Vec::with_capacity(signers.len());
1685
1686            for signer in signers {
1687                let cigar = signer.sign(ser, None, None, None)?;
1688                cigars.push(cigar);
1689            }
1690
1691            Ok(cigars)
1692        }
1693    }
1694
1695    /// Returns decrypted plaintext of encrypted qb64 ciphertext serialization.
1696    ///
1697    /// # Parameters
1698    /// * `qb64` - Fully qualified base64 ciphertext serialization to decrypt
1699    /// * `pubs` - Optional list of qb64 public keys to lookup private keys
1700    ///   one of pubs or verfers is required. If both then verfers is ignored.
1701    /// * `verfers` - Optional list of Verfer instances of public keys
1702    ///   one of pubs or verfers is required. If both then verfers is ignored.
1703    ///   If not pubs then gets public key from verfer.qb64 used to lookup
1704    ///   private keys
1705    ///
1706    /// # Returns
1707    /// * `Result<Vec<u8>, KERIError>` - Decrypted plaintext or error
1708    pub fn decrypt(
1709        &self,
1710        qb64: &[u8],
1711        pubs: Option<Vec<&str>>,
1712        verfers: Option<Vec<Verfer>>,
1713    ) -> Result<Vec<u8>, KERIError> {
1714        let mut signers = Vec::new();
1715
1716        // Handle pubs if provided
1717        if let Some(pub_keys) = pubs {
1718            for pub_key in pub_keys {
1719                // Check if we need decryption but don't have a decrypter
1720                if self.encrypter.is_some() && self.decrypter.is_none() {
1721                    return Err(KERIError::DecryptError(
1722                        "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1723                    ));
1724                }
1725
1726                // Get the signer from private keys database
1727                let signer = self
1728                    .ks
1729                    .pris
1730                    .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1731                    .ok_or_else(|| {
1732                        KERIError::ValueError(format!(
1733                            "Missing prikey in db for pubkey={}",
1734                            pub_key
1735                        ))
1736                    })?;
1737
1738                signers.push(signer);
1739            }
1740        }
1741        // Process verfers if provided and pubs was not provided
1742        else if let Some(verfer_list) = verfers {
1743            for verfer in verfer_list {
1744                // Check if we need decryption but don't have a decrypter
1745                if self.encrypter.is_some() && self.decrypter.is_none() {
1746                    return Err(KERIError::DecryptError(
1747                        "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1748                    ));
1749                }
1750
1751                // Get the signer from private keys database
1752                let signer = self
1753                    .ks
1754                    .pris
1755                    .get(&[verfer.qb64b().as_slice()], self.decrypter.clone())?
1756                    .ok_or_else(|| {
1757                        KERIError::ValueError(format!(
1758                            "Missing prikey in db for pubkey={}",
1759                            verfer.qb64()
1760                        ))
1761                    })?;
1762
1763                signers.push(signer);
1764            }
1765        } else {
1766            return Err(KERIError::ValueError(
1767                "Either pubs or verfers must be provided".to_string(),
1768            ));
1769        }
1770
1771        // Convert the input to bytes
1772        let qb64b = qb64.to_vec();
1773        let mut plain = Vec::new();
1774
1775        // Try decryption with each signer
1776        for signer in signers {
1777            // Combine the raw seed and raw verification key to create the signing key
1778            let mut sigkey = Vec::with_capacity(signer.raw().len() + signer.verfer().raw().len());
1779            sigkey.extend_from_slice(signer.raw());
1780            sigkey.extend_from_slice(signer.verfer().raw());
1781
1782            // Convert the signing key to a private encryption key (using sodium)
1783            let prikey = sodiumoxide::crypto::sign::ed25519::to_curve25519_sk(
1784                &SecretKey::from_slice(&sigkey).unwrap(),
1785            )
1786            .unwrap();
1787
1788            // Derive the public key from the private key
1789            let pubkey = prikey.public_key();
1790
1791            // Attempt to decrypt using the sealed box
1792            match sodiumoxide::crypto::sealedbox::open(&qb64b, &pubkey, &prikey) {
1793                Ok(decrypted) => {
1794                    plain = decrypted;
1795                    break;
1796                }
1797                Err(_) => continue, // Try the next signer if this one fails
1798            }
1799        }
1800
1801        // If the plain text is the same as the input, decryption failed
1802        if plain == qb64b {
1803            return Err(KERIError::ValueError("Unable to decrypt.".to_string()));
1804        }
1805
1806        Ok(plain)
1807    }
1808
1809    // TODO: Implement ingest and reply from KERIpy implementations.
1810}
1811
1812#[cfg(test)]
1813mod tests {
1814    use super::*;
1815    use crate::cesr::indexing::Indexer;
1816    use crate::cesr::signing::{Cipher, Signer};
1817    use crate::keri::db::dbing::LMDBer;
1818    use std::sync::Arc;
1819
1820    #[test]
1821    fn test_manager_creation() -> Result<(), KERIError> {
1822        let lmdber = LMDBer::builder()
1823            .name("manager_ks")
1824            .reopen(true)
1825            .build()
1826            .expect("Failed to open manager database: {}");
1827        let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
1828        let manager = Manager::new(keeper, None, None, None, None, None, None)?;
1829
1830        assert!(manager.inited);
1831        assert!(manager.encrypter.is_none());
1832        assert!(manager.decrypter.is_none());
1833        assert!(manager.seed().is_empty());
1834
1835        Ok(())
1836    }
1837
1838    #[test]
1839    fn test_manager() -> Result<(), KERIError> {
1840        // Setup with raw salt
1841        let raw = b"0123456789abcdef".to_vec();
1842        let salter = Salter::new(Some(&raw), None, None)?;
1843        let salt = salter.qb64b();
1844        let stem = "red";
1845
1846        assert_eq!(salt, b"0AAwMTIzNDU2Nzg5YWJjZGVm");
1847
1848        // Sample serialization for testing (specific content doesn't matter)
1849        let ser = br#"{"vs":"KERI10JSON0000fb_","pre":"EvEnZMhz52iTrJU8qKwtDxzmypyosgG70m6LIjkiCdoI","sn":"0","ilk":"icp","sith":"1","keys":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA"],"nxt":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU","toad":"0","wits":[],"cnfg":[]}-AABAApYcYd1cppVg7Inh2YCslWKhUwh59TrPpIoqWxN2A38NCbTljvmBPBjSGIFDBNOvVjHpdZlty3Hgk6ilF8pVpAQ"#.to_vec();
1850
1851        // Create a keeper and manager for testing
1852        let lmdber = LMDBer::builder()
1853            .name("manager_ks")
1854            .reopen(true)
1855            .build()
1856            .expect("Failed to open manager database: {}");
1857        let lmdber_arc = Arc::new(lmdber);
1858        let keeper = Keeper::new(lmdber_arc.clone()).expect("Failed to create manager database");
1859
1860        // Test invalid salt error
1861        let result = Manager::new(
1862            keeper,
1863            None,
1864            None,
1865            None,
1866            None,
1867            Some(b"0AzwMTIzNDU2Nzg5YWJjZGVm".to_vec()),
1868            None,
1869        );
1870        assert!(result.is_err());
1871        assert!(matches!(result, Err(KERIError::MatterError(_))));
1872
1873        // Create valid manager with salt
1874        let keeper = Keeper::new(lmdber_arc.clone()).expect("Failed to create manager database");
1875        let mut manager = Manager::new(keeper, None, None, None, None, Some(salt.clone()), None)?;
1876
1877        assert!(manager.ks.opened());
1878        assert_eq!(manager.pidx(), Some(0));
1879        assert_eq!(manager.tier(), Some(Tiers::LOW));
1880        assert_eq!(manager.salt(), Some(salt.clone()));
1881        assert_eq!(manager.aeid(), Vec::<u8>::new());
1882        assert_eq!(manager.seed(), &Vec::<u8>::new());
1883        assert!(manager.encrypter.is_none());
1884        assert!(manager.decrypter.is_none());
1885
1886        // Test salty algorithm incept
1887        let (verfers, digers) = manager.incept(
1888            None,
1889            None,
1890            None,
1891            None,
1892            None,
1893            None,
1894            None,
1895            None,
1896            Some(salt.clone()),
1897            None,
1898            None,
1899            None,
1900            None,
1901            Some(true),
1902        )?;
1903
1904        assert_eq!(verfers.len(), 1);
1905        assert_eq!(digers.len(), 1);
1906        assert_eq!(manager.pidx(), Some(1));
1907
1908        let spre = verfers[0].qb64b();
1909        assert_eq!(&spre, b"DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT");
1910
1911        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
1912        assert_eq!(pp.pidx, 0);
1913        assert_eq!(pp.algo, Algos::Salty.to_string());
1914        assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
1915        assert_eq!(pp.stem, "");
1916        assert_eq!(pp.tier, Tiers::LOW.to_string());
1917
1918        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
1919        assert!(ps.old.is_none());
1920        assert_eq!(ps.new.pubs.len(), 1);
1921        assert_eq!(
1922            ps.new.pubs,
1923            vec!["DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"]
1924        );
1925        assert_eq!(ps.new.ridx, 0);
1926        assert_eq!(ps.new.kidx, 0);
1927        assert_eq!(ps.nxt.pubs.len(), 1);
1928        assert_eq!(
1929            ps.nxt.pubs,
1930            vec!["DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"]
1931        );
1932        assert_eq!(ps.nxt.ridx, 1);
1933        assert_eq!(ps.nxt.kidx, 1);
1934
1935        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
1936        assert_eq!(keys, ps.new.pubs);
1937
1938        // Test .pubs db
1939        let pl = manager
1940            .ks
1941            .pubs
1942            .get(&[Keeper::ri_key(
1943                String::from_utf8(spre.clone()).unwrap().as_str(),
1944                ps.new.ridx as u64,
1945            )])?
1946            .unwrap();
1947        assert_eq!(pl.pubs, ps.new.pubs);
1948
1949        let pl = manager
1950            .ks
1951            .pubs
1952            .get(&[Keeper::ri_key(
1953                String::from_utf8(spre.clone()).unwrap().as_str(),
1954                ps.nxt.ridx as u64,
1955            )])?
1956            .unwrap();
1957        assert_eq!(pl.pubs, ps.nxt.pubs);
1958
1959        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
1960        assert_eq!(digs, vec!["EBhBRqVbqhhP7Ciah5pMIOdsY5Mm1ITm2Fjqb028tylu"]);
1961
1962        // Test move operation
1963        let oldspre = spre.clone();
1964        let spre = b"DCu5o5cxzv1lgMqxMVG3IcCNK4lpFfpMM-9rfkY3XVUc".to_vec();
1965        manager.move_prefix(&oldspre, &spre)?;
1966
1967        // Test .pubs db after move
1968        let pl = manager
1969            .ks
1970            .pubs
1971            .get(&[Keeper::ri_key(
1972                String::from_utf8(spre.clone()).unwrap().as_str(),
1973                ps.new.ridx as u64,
1974            )])?
1975            .unwrap();
1976        assert_eq!(pl.pubs, ps.new.pubs);
1977
1978        let pl = manager
1979            .ks
1980            .pubs
1981            .get(&[Keeper::ri_key(
1982                String::from_utf8(spre.clone()).unwrap().as_str(),
1983                ps.nxt.ridx as u64,
1984            )])?
1985            .unwrap();
1986        assert_eq!(pl.pubs, ps.nxt.pubs);
1987
1988        // Test signing with pubs
1989        let psigers = manager.sign(
1990            &ser,
1991            Some(ps.new.pubs.clone()),
1992            None,
1993            None,
1994            None,
1995            None,
1996            None,
1997            None,
1998        )?;
1999        for siger in &psigers {
2000            match siger {
2001                Sigmat::Indexed(_) => {}
2002                _ => panic!("Expected indexed signature"),
2003            }
2004        }
2005
2006        // Test signing with verfers
2007        let vsigers = manager.sign(
2008            &ser,
2009            None,
2010            Some(verfers.clone()),
2011            None,
2012            None,
2013            None,
2014            None,
2015            None,
2016        )?;
2017
2018        let psigs: Vec<String> = psigers
2019            .iter()
2020            .map(|s| {
2021                let Sigmat::Indexed(sig) = s else {
2022                    panic!("Not indexed")
2023                };
2024                sig.qb64()
2025            })
2026            .collect();
2027        let vsigs: Vec<String> = vsigers
2028            .iter()
2029            .map(|s| {
2030                let Sigmat::Indexed(sig) = s else {
2031                    panic!("Not indexed")
2032                };
2033                sig.qb64()
2034            })
2035            .collect();
2036
2037        assert_eq!(psigs, vsigs);
2038        assert_eq!(psigs, vec!["AAAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2039
2040        // Test sign with indices
2041        let indices = Some(vec![3]);
2042
2043        // Test with pubs list
2044        let psigers = manager.sign(
2045            &ser,
2046            Some(ps.new.pubs.clone()),
2047            None,
2048            None,
2049            indices.clone(),
2050            None,
2051            None,
2052            None,
2053        )?;
2054
2055        match &psigers[0] {
2056            Sigmat::Indexed(s) => assert_eq!(s.index(), 3),
2057            _ => panic!("Expected indexed signature"),
2058        }
2059
2060        let psigs: Vec<String> = psigers
2061            .iter()
2062            .map(|s| {
2063                let Sigmat::Indexed(sig) = s else {
2064                    panic!("Not indexed")
2065                };
2066                sig.qb64()
2067            })
2068            .collect();
2069        assert_eq!(psigs, vec!["ADAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2070
2071        // Test with verfers list
2072        let vsigers = manager.sign(
2073            &ser,
2074            None,
2075            Some(verfers.clone()),
2076            None,
2077            indices,
2078            None,
2079            None,
2080            None,
2081        )?;
2082
2083        match &vsigers[0] {
2084            Sigmat::Indexed(s) => assert_eq!(s.index(), 3),
2085            _ => panic!("Expected indexed signature"),
2086        }
2087
2088        let vsigs: Vec<String> = vsigers
2089            .iter()
2090            .map(|s| {
2091                let Sigmat::Indexed(sig) = s else {
2092                    panic!("Not indexed")
2093                };
2094                sig.qb64()
2095            })
2096            .collect();
2097        assert_eq!(vsigs, psigs);
2098
2099        // Test non-indexed signatures (cigars)
2100        let pcigars = manager.sign(
2101            &ser,
2102            Some(ps.new.pubs.clone()),
2103            None,
2104            Some(false),
2105            None,
2106            None,
2107            None,
2108            None,
2109        )?;
2110        for cigar in &pcigars {
2111            match cigar {
2112                Sigmat::NonIndexed(_) => (),
2113                _ => panic!("Expected non-indexed signature"),
2114            }
2115        }
2116
2117        let vcigars = manager.sign(
2118            &ser,
2119            None,
2120            Some(verfers.clone()),
2121            Some(false),
2122            None,
2123            None,
2124            None,
2125            None,
2126        )?;
2127
2128        let psigs: Vec<String> = pcigars
2129            .iter()
2130            .map(|s| {
2131                let Sigmat::NonIndexed(sig) = s else {
2132                    panic!("Not indexed")
2133                };
2134                sig.qb64()
2135            })
2136            .collect();
2137        let vsigs: Vec<String> = vcigars
2138            .iter()
2139            .map(|s| {
2140                let Sigmat::NonIndexed(sig) = s else {
2141                    panic!("Not indexed")
2142                };
2143                sig.qb64()
2144            })
2145            .collect();
2146
2147        assert_eq!(psigs, vsigs);
2148        assert_eq!(psigs, vec!["0BAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2149
2150        // Test salty algorithm rotate
2151        let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2152        let (verfers, digers) = manager.rotate(
2153            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2154            None,
2155            None,
2156            None,
2157            None,
2158            None,
2159            None,
2160            None,
2161        )?;
2162
2163        assert_eq!(verfers.len(), 1);
2164        assert_eq!(digers.len(), 1);
2165
2166        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2167        assert_eq!(pp.pidx, 0);
2168        assert_eq!(pp.algo, Algos::Salty.to_string());
2169        assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
2170        assert_eq!(pp.stem, "");
2171        assert_eq!(pp.tier, Tiers::LOW.to_string());
2172
2173        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2174        assert_eq!(
2175            ps.old.clone().unwrap().pubs,
2176            vec!["DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"]
2177        );
2178        assert_eq!(ps.new.pubs.len(), 1);
2179        assert_eq!(
2180            ps.new.pubs,
2181            vec!["DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"]
2182        );
2183        assert_eq!(ps.new.ridx, 1);
2184        assert_eq!(ps.new.kidx, 1);
2185        assert_eq!(ps.nxt.pubs.len(), 1);
2186        assert_eq!(
2187            ps.nxt.pubs,
2188            vec!["DAoQ1WxT29XtCFtOpJZyuO2q38BD8KTefktf7X0WN4YW"]
2189        );
2190        assert_eq!(ps.nxt.ridx, 2);
2191        assert_eq!(ps.nxt.kidx, 2);
2192
2193        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2194        assert_eq!(keys, ps.new.pubs);
2195
2196        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2197        assert_eq!(digs, vec!["EJczV8HmnEWZiEHw2lVuSatrvzCmJOZ3zpa7JFfrnjau"]);
2198
2199        assert_eq!(oldpubs, ps.old.clone().unwrap().pubs);
2200
2201        // Test salty algorithm rotate again
2202        let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2203        let deadpubs = ps.old.clone().unwrap().pubs.clone();
2204
2205        let (_verfers, _digers) = manager.rotate(
2206            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2207            None,
2208            None,
2209            None,
2210            None,
2211            None,
2212            None,
2213            None,
2214        )?;
2215
2216        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2217        assert_eq!(pp.pidx, 0);
2218
2219        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2220        assert_eq!(oldpubs, ps.old.unwrap().pubs);
2221
2222        // Check that old keys are removed
2223        for pub_key in deadpubs {
2224            assert!(manager.ks.pris.get(&[pub_key.as_bytes()], None)?.is_none());
2225        }
2226
2227        // Test .pubs db
2228        let pl = manager
2229            .ks
2230            .pubs
2231            .get(&[Keeper::ri_key(
2232                String::from_utf8(spre.clone()).unwrap().as_str(),
2233                ps.new.ridx as u64,
2234            )])?
2235            .unwrap();
2236        assert_eq!(pl.pubs, ps.new.pubs);
2237
2238        let pl = manager
2239            .ks
2240            .pubs
2241            .get(&[Keeper::ri_key(
2242                String::from_utf8(spre.clone()).unwrap().as_str(),
2243                ps.nxt.ridx as u64,
2244            )])?
2245            .unwrap();
2246        assert_eq!(pl.pubs, ps.nxt.pubs);
2247
2248        // Test salty algorithm rotate to null (non-transferable)
2249        let (_verfers, digers) = manager.rotate(
2250            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2251            None,
2252            Some(0),
2253            None,
2254            None,
2255            None,
2256            None,
2257            None,
2258        )?;
2259
2260        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2261        assert_eq!(pp.pidx, 0);
2262
2263        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2264        assert!(ps.nxt.pubs.is_empty());
2265        assert!(digers.is_empty());
2266
2267        // Test attempt to rotate after null (should fail)
2268        let result = manager.rotate(
2269            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2270            None,
2271            None,
2272            None,
2273            None,
2274            None,
2275            None,
2276            None,
2277        );
2278
2279        assert!(result.is_err());
2280        let err = result.unwrap_err();
2281        match err {
2282            KERIError::ValueError(msg) => {
2283                assert!(msg.starts_with("Attempt to rotate nontransferable"));
2284            }
2285            _ => panic!("Expected ValueError"),
2286        }
2287
2288        // Test randy algorithm incept
2289        let (verfers, digers) = manager.incept(
2290            None,
2291            None,
2292            None,
2293            None,
2294            None,
2295            None,
2296            None,
2297            Some(Algos::Randy),
2298            None,
2299            None,
2300            None,
2301            None,
2302            None,
2303            None,
2304        )?;
2305
2306        assert_eq!(verfers.len(), 1);
2307        assert_eq!(digers.len(), 1);
2308        assert_eq!(manager.pidx(), Some(2));
2309
2310        let rpre = verfers[0].qb64b();
2311
2312        let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2313        assert_eq!(pp.pidx, 1);
2314        assert_eq!(pp.algo, Algos::Randy.to_string());
2315        assert_eq!(pp.salt, "");
2316        assert_eq!(pp.stem, "");
2317        assert_eq!(pp.tier, "");
2318
2319        let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2320        assert!(ps.old.is_none());
2321        assert_eq!(ps.new.pubs.len(), 1);
2322        assert_eq!(ps.new.ridx, 0);
2323        assert_eq!(ps.new.kidx, 0);
2324        assert_eq!(ps.nxt.pubs.len(), 1);
2325        assert_eq!(ps.nxt.ridx, 1);
2326        assert_eq!(ps.nxt.kidx, 1);
2327
2328        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2329        for key in &keys {
2330            assert!(manager.ks.pris.get(&[key.as_bytes()], None)?.is_some());
2331        }
2332
2333        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2334        assert_eq!(digs.len(), 1);
2335
2336        // Test move with randy prefixes
2337        let oldrpre = rpre.clone();
2338        let rpre = b"DMqxMVG3IcCNK4lpFfCu5o5cxzv1lgpMM-9rfkY3XVUc".to_vec();
2339        manager.move_prefix(&oldrpre, &rpre)?;
2340
2341        // Test randy algorithm rotate
2342        let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2343
2344        let (_verfers, _digers) = manager.rotate(
2345            &String::from_utf8(rpre.clone()).unwrap().as_bytes(),
2346            None,
2347            None,
2348            None,
2349            None,
2350            None,
2351            None,
2352            None,
2353        )?;
2354
2355        let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2356        assert_eq!(pp.pidx, 1);
2357
2358        let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2359        assert_eq!(oldpubs, ps.old.unwrap().pubs);
2360
2361        // Test randy algorithm incept with null next keys
2362        let (verfers, digers) = manager.incept(
2363            None,
2364            None,
2365            None,
2366            None,
2367            Some(0),
2368            None,
2369            None,
2370            Some(Algos::Randy),
2371            None,
2372            None,
2373            None,
2374            None,
2375            None,
2376            None,
2377        )?;
2378
2379        assert_eq!(manager.pidx(), Some(3));
2380        let rpre = verfers[0].qb64b();
2381
2382        let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2383        assert_eq!(pp.pidx, 2);
2384
2385        let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2386        assert!(ps.nxt.pubs.is_empty());
2387        assert!(digers.is_empty());
2388
2389        // Test attempt to rotate after null (should fail)
2390        let result = manager.rotate(
2391            &String::from_utf8(rpre.clone()).unwrap().as_bytes(),
2392            None,
2393            None,
2394            None,
2395            None,
2396            None,
2397            None,
2398            None,
2399        );
2400
2401        assert!(result.is_err());
2402
2403        // Test salty algorithm incept with stem
2404        let (verfers, digers) = manager.incept(
2405            None,
2406            None,
2407            None,
2408            None,
2409            None,
2410            None,
2411            None,
2412            None,
2413            Some(salt.clone()),
2414            Some(stem),
2415            None,
2416            None,
2417            None,
2418            Some(true),
2419        )?;
2420
2421        assert_eq!(verfers.len(), 1);
2422        assert_eq!(digers.len(), 1);
2423        assert_eq!(manager.pidx(), Some(4));
2424
2425        let spre = verfers[0].qb64b();
2426        assert_eq!(&spre, b"DOtu4gX3oc4feusD8wWIykLhjkpiJHXEe29eJ2b_1CyM");
2427
2428        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2429        assert_eq!(pp.pidx, 3);
2430        assert_eq!(pp.algo, Algos::Salty.to_string());
2431        assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
2432        assert_eq!(pp.stem, stem);
2433        assert_eq!(pp.tier, Tiers::LOW.to_string());
2434
2435        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2436        assert!(ps.old.is_none());
2437        assert_eq!(ps.new.pubs.len(), 1);
2438        assert_eq!(
2439            ps.new.pubs,
2440            vec!["DOtu4gX3oc4feusD8wWIykLhjkpiJHXEe29eJ2b_1CyM"]
2441        );
2442        assert_eq!(ps.new.ridx, 0);
2443        assert_eq!(ps.new.kidx, 0);
2444        assert_eq!(ps.nxt.pubs.len(), 1);
2445        assert_eq!(
2446            ps.nxt.pubs,
2447            vec!["DBzZ6vejSNAZpXv1SDRnIF_P1UqcW5d2pu2U-v-uhXvE"]
2448        );
2449        assert_eq!(ps.nxt.ridx, 1);
2450        assert_eq!(ps.nxt.kidx, 1);
2451
2452        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2453        assert_eq!(keys, ps.new.pubs);
2454
2455        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2456        assert_eq!(digs, vec!["EIGjhyyBRcqCkPE9bmkph7morew0wW0ak-rQ-dHCH-M2"]);
2457
2458        // Test attempt to reincept same first pub (should fail)
2459        let result = manager.incept(
2460            None,
2461            None,
2462            None,
2463            None,
2464            None,
2465            None,
2466            None,
2467            None,
2468            Some(salt.clone()),
2469            Some(stem),
2470            None,
2471            None,
2472            None,
2473            Some(true),
2474        );
2475
2476        assert!(result.is_err());
2477        let err = result.unwrap_err();
2478        match err {
2479            KERIError::ValueError(msg) => {
2480                assert!(msg.starts_with("Already incepted pre"));
2481            }
2482            _ => panic!("Expected ValueError"),
2483        }
2484
2485        // Test move and then attempt to reincept
2486        let oldspre = spre.clone();
2487        let spre = b"DCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxMVG3Ic".to_vec();
2488        manager.move_prefix(&oldspre, &spre)?;
2489
2490        // Test attempt to reincept same first pub after move pre (should fail)
2491        let result = manager.incept(
2492            None,
2493            None,
2494            None,
2495            None,
2496            None,
2497            None,
2498            None,
2499            None,
2500            Some(salt.clone()),
2501            Some(stem),
2502            None,
2503            None,
2504            None,
2505            Some(true),
2506        );
2507
2508        assert!(result.is_err());
2509        let err = result.unwrap_err();
2510        match err {
2511            KERIError::ValueError(msg) => {
2512                assert!(msg.starts_with("Already incepted pre"));
2513            }
2514            _ => panic!("Expected ValueError"),
2515        }
2516
2517        // Test creating nontransferable keys for witnesses
2518        let (verfers, digers) = manager.incept(
2519            None,
2520            None,
2521            None,
2522            None,
2523            Some(0),
2524            None,
2525            None,
2526            None,
2527            Some(salt.clone()),
2528            Some("wit0"),
2529            None,
2530            None,
2531            Some(false),
2532            Some(true),
2533        )?;
2534
2535        let wit0pre = verfers[0].qb64();
2536        assert_eq!(wit0pre, "BOTNI4RzN706NecNdqTlGEcMSTWiFUvesEqmxWR_op8n");
2537        assert_eq!(verfers[0].code(), mtr_dex::ED25519N);
2538        assert!(digers.is_empty());
2539
2540        let (verfers, digers) = manager.incept(
2541            None,
2542            None,
2543            None,
2544            None,
2545            Some(0),
2546            None,
2547            None,
2548            None,
2549            Some(salt.clone()),
2550            Some("wit1"),
2551            None,
2552            None,
2553            Some(false),
2554            Some(true),
2555        )?;
2556
2557        let wit1pre = verfers[0].qb64();
2558        assert_eq!(wit1pre, "BAB_5xNXH4hoxDCtAHPFPDedZ6YwTo8mbdw_v0AOHOMt");
2559        assert_eq!(verfers[0].code(), mtr_dex::ED25519N);
2560        assert!(digers.is_empty());
2561
2562        assert_ne!(wit0pre, wit1pre);
2563
2564        Ok(())
2565    }
2566
2567    #[test]
2568    fn test_manager_with_aeid() -> Result<(), KERIError> {
2569        // Create test salt
2570        let rawsalt = b"0123456789abcdef".to_vec();
2571        let salter = Salter::new(Some(&rawsalt), None, None)?;
2572        let salt = salter.qb64();
2573        assert_eq!(salt, "0AAwMTIzNDU2Nzg5YWJjZGVm");
2574
2575        // First crypto seed
2576        let cryptseed0 =
2577            b"h,#|\x8ap\"\x12\xc43t2\xa6\xe1\x18\x19\xf0f2,y\xc4\xc21@\xf5@\x15.\xa2\x1a\xcf"
2578                .to_vec();
2579        let cryptsigner0 = Signer::new(
2580            Some(&cryptseed0),
2581            Some("A"), // ED25519_Seed code
2582            Some(false),
2583        )?;
2584
2585        let seed0 = cryptsigner0.qb64();
2586        let aeid0 = cryptsigner0.verfer().qb64();
2587        assert_eq!(aeid0, "BCa7mK96FwxkU0TdF54Yqg3qBDXUWpOhQ_Mtr7E77yZB");
2588
2589        let decrypter0 = Decrypter::new(None, None, Some(seed0.as_bytes()))?;
2590        let encrypter0 = Encrypter::new(None, None, Some(aeid0.as_bytes()))?;
2591        assert!(encrypter0.verify_seed(seed0.as_bytes())?);
2592
2593        // Second crypto seed
2594        let cryptseed1 = b"\x89\xfe{\xd9'\xa7\xb3\x89#\x19\xbec\xee\xed\xc0\xf9\x97\xd0\x8f9\x1dyNII\x98\xbd\xa4\xf6\xfe\xbb\x03".to_vec();
2595        let cryptsigner1 = Signer::new(
2596            Some(&cryptseed1),
2597            Some("A"), // ED25519_Seed code
2598            Some(false),
2599        )?;
2600
2601        let seed1 = cryptsigner1.qb64();
2602        let aeid1 = cryptsigner1.verfer().qb64();
2603        assert_eq!(aeid1, "BEcOrMrG_7r_NWaLl6h8UJapwIfQWIkjrIPXkCZm2fFM");
2604
2605        let decrypter1 = Decrypter::new(None, None, Some(seed1.as_bytes()))?;
2606        let encrypter1 = Encrypter::new(None, None, Some(aeid1.as_bytes()))?;
2607        assert!(encrypter1.verify_seed(seed1.as_bytes())?);
2608
2609        // Test data to sign
2610        let ser = br#"{"vs":"KERI10JSON0000fb_","pre":"EvEnZMhz52iTrJU8qKwtDxzmypyosgG70m6LIjkiCdoI","sn":"0","ilk":"icp","sith":"1","keys":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA"],"nxt":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU","toad":"0","wits":[],"cnfg":[]}-AABAApYcYd1cppVg7Inh2YCslWKhUwh59TrPpIoqWxN2A38NCbTljvmBPBjSGIFDBNOvVjHpdZlty3Hgk6ilF8pVpAQ"#.to_vec();
2611
2612        // Create a key store and manager
2613        let lmdber = LMDBer::builder()
2614            .name("manager_ks")
2615            .reopen(true)
2616            .build()
2617            .expect("Failed to open manager database: {}");
2618        let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
2619
2620        // Create manager with encryption/decryption due to aeid and seed
2621        let mut manager = Manager::new(
2622            keeper,
2623            Some(seed0.as_bytes().to_vec()),
2624            Some(aeid0.as_bytes().to_vec()),
2625            None,
2626            None,
2627            Some(salt.as_bytes().to_vec()),
2628            None,
2629        )?;
2630
2631        assert!(manager.ks.opened());
2632        assert!(manager.inited);
2633
2634        // Validate inits data
2635        assert_eq!(manager.salt(), Some(b"0AAwMTIzNDU2Nzg5YWJjZGVm".to_vec()));
2636        assert_eq!(
2637            manager.aeid(),
2638            b"BCa7mK96FwxkU0TdF54Yqg3qBDXUWpOhQ_Mtr7E77yZB".to_vec()
2639        );
2640
2641        // Validate encryption decryption inited correctly
2642        assert_eq!(
2643            manager.encrypter.as_ref().unwrap().qb64(),
2644            encrypter0.qb64()
2645        );
2646        assert_eq!(
2647            manager.decrypter.as_ref().unwrap().qb64(),
2648            decrypter0.qb64()
2649        );
2650        assert_eq!(manager.seed(), &seed0.as_bytes().to_vec());
2651        assert_eq!(manager.aeid(), aeid0.as_bytes().to_vec());
2652
2653        assert_eq!(manager.algo().unwrap(), Algos::Salty.to_string());
2654        assert_eq!(manager.salt().unwrap(), salt.as_bytes().to_vec());
2655        assert_eq!(manager.pidx().unwrap(), 0);
2656        assert_eq!(manager.tier().unwrap(), Tiers::LOW);
2657
2658        // Verify salt is encrypted on disk but property decrypts if seed is available
2659        let mut stored_salt = manager.ks.gbls.get(&["salt"])?.unwrap();
2660        let salt_cipher0 = Cipher::from_qb64b(&mut stored_salt, None)?;
2661
2662        let decrypted = salt_cipher0.decrypt(None, Some(seed0.as_bytes()), None, None)?;
2663        let decrypted_matter = decrypted
2664            .downcast_ref::<Salter>()
2665            .expect("Failed to downcast to Salter");
2666        assert_eq!(decrypted_matter.qb64(), salt);
2667
2668        // Test salty algorithm incept
2669        let (verfers, digers) = manager.incept(
2670            None,
2671            None,
2672            None,
2673            None,
2674            None,
2675            None,
2676            None,
2677            None,
2678            Some(salt.as_bytes().to_vec()),
2679            None,
2680            None,
2681            None,
2682            None,
2683            Some(true),
2684        )?;
2685
2686        assert_eq!(verfers.len(), 1);
2687        assert_eq!(digers.len(), 1);
2688        assert_eq!(manager.pidx().unwrap(), 1);
2689
2690        let spre = verfers[0].qb64b();
2691        assert_eq!(
2692            String::from_utf8(spre.clone()).unwrap(),
2693            "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2694        );
2695
2696        // Verify prefix parameters
2697        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2698        assert_eq!(pp.pidx, 0);
2699        assert_eq!(pp.algo, Algos::Salty.to_string());
2700
2701        // Decrypt and check the salt in parameters
2702        let _decrypted_salt = manager.decrypter.as_ref().unwrap().decrypt(
2703            None,
2704            Some(pp.salt.as_str()),
2705            None,
2706            None,
2707            None,
2708        )?;
2709        // assert_eq!(decrypted_salt, salt.as_bytes());
2710
2711        assert_eq!(pp.stem, "");
2712        assert_eq!(pp.tier, Tiers::LOW.to_string());
2713
2714        // Verify prefix situation
2715        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2716        assert!(ps.old.is_none());
2717        assert_eq!(ps.new.pubs.len(), 1);
2718        assert_eq!(
2719            ps.new.pubs[0],
2720            "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2721        );
2722        assert_eq!(ps.new.ridx, 0);
2723        assert_eq!(ps.new.kidx, 0);
2724        assert_eq!(ps.nxt.pubs.len(), 1);
2725        assert_eq!(
2726            ps.nxt.pubs[0],
2727            "DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"
2728        );
2729        assert_eq!(ps.nxt.ridx, 1);
2730        assert_eq!(ps.nxt.kidx, 1);
2731
2732        // Verify key lists match
2733        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2734        assert_eq!(keys, ps.new.pubs);
2735
2736        // Test pubs database
2737        let ri_key = Keeper::ri_key(
2738            &String::from_utf8(spre.clone()).unwrap(),
2739            ps.new.ridx as u64,
2740        );
2741        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2742        assert_eq!(pl.pubs, ps.new.pubs);
2743
2744        let ri_key = Keeper::ri_key(
2745            &String::from_utf8(spre.clone()).unwrap(),
2746            ps.nxt.ridx as u64,
2747        );
2748        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2749        assert_eq!(pl.pubs, ps.nxt.pubs);
2750
2751        // Verify digests
2752        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2753        assert_eq!(digs[0], "EBhBRqVbqhhP7Ciah5pMIOdsY5Mm1ITm2Fjqb028tylu");
2754
2755        // Test move operation
2756        let oldspre = spre.clone();
2757        let spre = b"DCu5o5cxzv1lgMqxMVG3IcCNK4lpFfpMM-9rfkY3XVUc".to_vec();
2758        manager.move_prefix(&oldspre, &spre)?;
2759
2760        // Test pubs database after move
2761        let ri_key = Keeper::ri_key(
2762            &String::from_utf8(spre.clone()).unwrap(),
2763            ps.new.ridx as u64,
2764        );
2765        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2766        assert_eq!(pl.pubs, ps.new.pubs);
2767
2768        let ri_key = Keeper::ri_key(
2769            &String::from_utf8(spre.clone()).unwrap(),
2770            ps.nxt.ridx as u64,
2771        );
2772        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2773        assert_eq!(pl.pubs, ps.nxt.pubs);
2774
2775        // Test signing with pubs list
2776        let psigers = manager.sign(
2777            &ser,
2778            Some(ps.new.pubs.clone()),
2779            None,
2780            None,
2781            None,
2782            None,
2783            None,
2784            None,
2785        )?;
2786        for siger in &psigers {
2787            assert!(matches!(siger, Sigmat::Indexed(_)));
2788        }
2789
2790        // Test signing with verfers list
2791        let vsigers = manager.sign(
2792            &ser,
2793            None,
2794            Some(verfers.clone()),
2795            None,
2796            None,
2797            None,
2798            None,
2799            None,
2800        )?;
2801
2802        let psigs: Vec<String> = psigers
2803            .iter()
2804            .map(|s| {
2805                let Sigmat::Indexed(sig) = s else {
2806                    panic!("Not indexed")
2807                };
2808                sig.qb64()
2809            })
2810            .collect();
2811        let vsigs: Vec<String> = vsigers
2812            .iter()
2813            .map(|s| {
2814                let Sigmat::Indexed(sig) = s else {
2815                    panic!("Not indexed")
2816                };
2817                sig.qb64()
2818            })
2819            .collect();
2820
2821        assert_eq!(psigs, vsigs);
2822        assert_eq!(psigs[0], "AAAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2823
2824        // Test signing with indices
2825        let indices = Some(vec![3]);
2826
2827        // Test with pubs list and indices
2828        let psigers = manager.sign(
2829            &ser,
2830            Some(ps.new.pubs.clone()),
2831            None,
2832            None,
2833            indices.clone(),
2834            None,
2835            None,
2836            None,
2837        )?;
2838
2839        if let Sigmat::Indexed(siger) = &psigers[0] {
2840            assert_eq!(siger.index(), 3);
2841        } else {
2842            panic!("Expected indexed signature");
2843        }
2844
2845        let psigs: Vec<String> = psigers
2846            .iter()
2847            .map(|s| {
2848                let Sigmat::Indexed(sig) = s else {
2849                    panic!("Not indexed")
2850                };
2851                sig.qb64()
2852            })
2853            .collect();
2854        assert_eq!(psigs[0], "ADAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2855
2856        // Test with verfers list and indices
2857        let vsigers = manager.sign(
2858            &ser,
2859            None,
2860            Some(verfers.clone()),
2861            None,
2862            indices,
2863            None,
2864            None,
2865            None,
2866        )?;
2867
2868        if let Sigmat::Indexed(siger) = &vsigers[0] {
2869            assert_eq!(siger.index(), 3);
2870        } else {
2871            panic!("Expected indexed signature");
2872        }
2873
2874        let vsigs: Vec<String> = vsigers
2875            .iter()
2876            .map(|s| {
2877                let Sigmat::Indexed(sig) = s else {
2878                    panic!("Not indexed")
2879                };
2880                sig.qb64()
2881            })
2882            .collect();
2883        assert_eq!(vsigs, psigs);
2884
2885        // Test non-indexed signatures (cigars)
2886        let pcigars = manager.sign(
2887            &ser,
2888            Some(ps.new.pubs.clone()),
2889            None,
2890            Some(false),
2891            None,
2892            None,
2893            None,
2894            None,
2895        )?;
2896        for cigar in &pcigars {
2897            assert!(matches!(cigar, Sigmat::NonIndexed(_)));
2898        }
2899
2900        let vcigars = manager.sign(
2901            &ser,
2902            None,
2903            Some(verfers.clone()),
2904            Some(false),
2905            None,
2906            None,
2907            None,
2908            None,
2909        )?;
2910
2911        let psigs: Vec<String> = pcigars
2912            .iter()
2913            .map(|s| {
2914                let Sigmat::NonIndexed(sig) = s else {
2915                    panic!("Not indexed")
2916                };
2917                sig.qb64()
2918            })
2919            .collect();
2920        let vsigs: Vec<String> = vcigars
2921            .iter()
2922            .map(|s| {
2923                let Sigmat::NonIndexed(sig) = s else {
2924                    panic!("Not indexed")
2925                };
2926                sig.qb64()
2927            })
2928            .collect();
2929
2930        assert_eq!(psigs, vsigs);
2931        assert_eq!(psigs[0], "0BAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2932
2933        // Test salty algorithm rotate
2934        let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2935        let (verfers, digers) = manager.rotate(
2936            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2937            None,
2938            None,
2939            None,
2940            None,
2941            None,
2942            None,
2943            None,
2944        )?;
2945
2946        assert_eq!(verfers.len(), 1);
2947        assert_eq!(digers.len(), 1);
2948
2949        // Verify parameters after rotation
2950        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2951        assert_eq!(pp.pidx, 0);
2952        assert_eq!(pp.algo, Algos::Salty.to_string());
2953
2954        // Decrypt and verify salt
2955        let _decrypted_salt = manager.decrypter.as_ref().unwrap().decrypt(
2956            None,
2957            Some(pp.salt.as_str()),
2958            None,
2959            None,
2960            None,
2961        )?;
2962        // assert_eq!(decrypted_salt, salt.as_bytes());
2963
2964        assert_eq!(pp.stem, "");
2965        assert_eq!(pp.tier, Tiers::LOW.to_string());
2966
2967        // Verify situation after rotation
2968        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2969        assert_eq!(
2970            ps.old.as_ref().unwrap().pubs[0],
2971            "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2972        );
2973        assert_eq!(ps.new.pubs.len(), 1);
2974        assert_eq!(
2975            ps.new.pubs[0],
2976            "DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"
2977        );
2978        assert_eq!(ps.new.ridx, 1);
2979        assert_eq!(ps.new.kidx, 1);
2980        assert_eq!(ps.nxt.pubs.len(), 1);
2981        assert_eq!(
2982            ps.nxt.pubs[0],
2983            "DAoQ1WxT29XtCFtOpJZyuO2q38BD8KTefktf7X0WN4YW"
2984        );
2985        assert_eq!(ps.nxt.ridx, 2);
2986        assert_eq!(ps.nxt.kidx, 2);
2987
2988        // Verify keys match
2989        let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2990        assert_eq!(keys, ps.new.pubs);
2991
2992        // Verify digests
2993        let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2994        assert_eq!(digs[0], "EJczV8HmnEWZiEHw2lVuSatrvzCmJOZ3zpa7JFfrnjau");
2995
2996        // Verify old pubs match
2997        assert_eq!(oldpubs, ps.old.as_ref().unwrap().pubs);
2998
2999        // Update aeid and seed
3000        manager.update_aeid(aeid1.as_bytes().to_vec(), seed1.as_bytes().to_vec())?;
3001        assert_eq!(
3002            manager.encrypter.as_ref().unwrap().qb64(),
3003            encrypter1.qb64()
3004        );
3005        assert_eq!(
3006            manager.decrypter.as_ref().unwrap().qb64(),
3007            decrypter1.qb64()
3008        );
3009        assert_eq!(manager.seed(), &seed1.as_bytes().to_vec());
3010        assert_eq!(manager.aeid(), aeid1.as_bytes().to_vec());
3011
3012        assert_eq!(manager.algo().unwrap(), Algos::Salty.to_string());
3013        assert_eq!(manager.salt().unwrap(), salt.as_bytes().to_vec());
3014        assert_eq!(manager.pidx().unwrap(), 1);
3015        assert_eq!(manager.tier().unwrap(), Tiers::LOW);
3016
3017        // Check that salt cipher is updated
3018
3019        let mut stored_salt = manager.ks.gbls.get(&["salt"])?.unwrap();
3020        let salt_cipher1 = Cipher::from_qb64b(&mut stored_salt, None)?;
3021        // assert_eq!(salt_cipher1.decrypt(None, Some(seed1.as_bytes()), None, None)?.qb64(), salt);
3022
3023        // Verify old cipher is different from new cipher
3024        assert_ne!(salt_cipher0.qb64(), salt_cipher1.qb64());
3025
3026        // Test another rotation
3027        let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
3028        let deadpubs = ps.old.as_ref().unwrap().pubs.clone();
3029
3030        let (_verfers, _digers) = manager.rotate(
3031            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
3032            None,
3033            None,
3034            None,
3035            None,
3036            None,
3037            None,
3038            None,
3039        )?;
3040
3041        // Verify parameters
3042        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
3043        assert_eq!(pp.pidx, 0);
3044
3045        // Verify situation
3046        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
3047        assert_eq!(oldpubs, ps.old.as_ref().unwrap().pubs);
3048
3049        // Verify old keys are removed
3050        for pub_key in deadpubs {
3051            assert!(manager.ks.pris.get(&[pub_key.as_bytes()], None)?.is_none());
3052        }
3053
3054        // Test pubs database
3055        let ri_key = Keeper::ri_key(
3056            &String::from_utf8(spre.clone()).unwrap(),
3057            ps.new.ridx as u64,
3058        );
3059        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
3060        assert_eq!(pl.pubs, ps.new.pubs);
3061
3062        let ri_key = Keeper::ri_key(
3063            &String::from_utf8(spre.clone()).unwrap(),
3064            ps.nxt.ridx as u64,
3065        );
3066        let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
3067        assert_eq!(pl.pubs, ps.nxt.pubs);
3068
3069        // Test rotation to null (ncount=0)
3070        let (_verfers, digers) = manager.rotate(
3071            &String::from_utf8(spre.clone()).unwrap().as_bytes(),
3072            None,
3073            Some(0),
3074            None,
3075            None,
3076            None,
3077            None,
3078            None,
3079        )?;
3080
3081        // Verify parameters after null rotation
3082        let pp = manager.ks.prms.get(&[&spre])?.unwrap();
3083        assert_eq!(pp.pidx, 0);
3084
3085        // Verify situation after null rotation
3086        let ps = manager.ks.sits.get(&[&spre])?.unwrap();
3087        assert!(ps.nxt.pubs.is_empty());
3088        assert!(digers.is_empty());
3089
3090        // Try to rotate after null - should fail
3091        let result = manager.rotate(
3092            &String::from_utf8(spre).unwrap().as_bytes(),
3093            None,
3094            None,
3095            None,
3096            None,
3097            None,
3098            None,
3099            None,
3100        );
3101
3102        assert!(result.is_err());
3103        match result {
3104            Err(KERIError::ValueError(msg)) => {
3105                assert!(msg.starts_with("Attempt to rotate nontransferable"));
3106            }
3107            _ => panic!("Expected ValueError"),
3108        }
3109
3110        Ok(())
3111    }
3112}