Skip to main content

libkeri/keri/db/subing/
signer.rs

1use crate::cesr::signing::{Decrypter, Encrypter, Signer};
2use crate::cesr::verfer::Verfer;
3use crate::cesr::Parsable;
4use crate::keri::db::dbing::LMDBer;
5use crate::keri::db::subing::cesr::{CesrSuber, CesrSuberBase};
6use crate::keri::db::subing::SuberError;
7use crate::Matter;
8use std::sync::Arc;
9
10pub trait SignerTrait: Matter + Parsable {
11    fn with_transferable(qb64b: &[u8], transferable: bool) -> Result<Self, SuberError>;
12}
13
14pub struct SignerSuber {
15    base: CesrSuber<Signer>,
16}
17
18impl SignerSuber {
19    pub fn new(
20        db: Arc<LMDBer>,
21        subkey: &str,
22        sep: Option<u8>,
23        verify: bool,
24    ) -> Result<Self, SuberError> {
25        let base = CesrSuber::new(db, subkey, sep, verify)?;
26        Ok(Self { base })
27    }
28
29    /// Gets Signer instance at keys
30    ///
31    /// # Arguments
32    /// * `keys` - key bytes to be combined in order to form key. Last element of keys is verkey
33    ///   used to determine .transferable for Signer
34    ///
35    /// # Returns
36    /// * `Option<S>` - Signer instance with transferable property set correctly or None if no entry
37    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<Signer>, SuberError> {
38        if keys.is_empty() {
39            return Err(SuberError::EmptyKeys);
40        }
41
42        // Get raw value from database
43        let key_result = self.base.get_full_item_iter(keys, false)?;
44        if key_result.is_empty() {
45            return Ok(None);
46        }
47
48        let (ikeys, raw_val) = &key_result[0];
49
50        // Get the verkey (last element of keys)
51        let verkey = if let Some(last_key) = ikeys.last() {
52            last_key
53        } else {
54            return Err(SuberError::EmptyKeys);
55        };
56
57        // Create Verfer from verkey to determine transferability
58        let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
59        let transferable = verfer.is_transferable();
60
61        // Create Signer with the correct transferable property
62        let mut qb64b = raw_val.clone();
63        let signer = Signer::from_qb64b_and_transferable(&mut qb64b, None, transferable)?;
64
65        Ok(Some(signer))
66    }
67
68    /// Returns iterator over items in the subdb whose key starts with the provided keys
69    ///
70    /// # Arguments
71    /// * `keys` - Optional prefix keys to filter results
72    /// * `topive` - If true, treat as partial key tuple from top branch
73    ///
74    /// # Returns
75    /// * Vector of tuples containing (keys, signer instance)
76    pub fn get_item_iter<K: AsRef<[u8]>>(
77        &self,
78        keys: &[K],
79        topive: bool,
80    ) -> Result<Vec<(Vec<Vec<u8>>, Signer)>, SuberError> {
81        let items = self.base.get_full_item_iter(keys, topive)?;
82        let mut result = Vec::with_capacity(items.len());
83
84        for (ikeys, val) in items {
85            // Get verkey (last element of keys)
86            let verkey = if let Some(last_key) = ikeys.last() {
87                last_key
88            } else {
89                continue;
90            };
91
92            // Create Verfer from verkey to determine transferability
93            let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
94            let transferable = verfer.is_transferable();
95
96            // Create Signer with the correct transferable property
97            let mut qb64b = val.clone();
98            let signer = Signer::from_qb64b_and_transferable(&mut qb64b, None, transferable)?;
99            result.push((ikeys, signer));
100        }
101
102        Ok(result)
103    }
104
105    // Forward other methods to the base implementation
106    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &Signer) -> Result<bool, SuberError> {
107        Ok(self.base.put(keys, val)?)
108    }
109
110    // Forward other methods to the base implementation
111    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &Signer) -> Result<bool, SuberError> {
112        Ok(self.base.pin(keys, val)?)
113    }
114
115    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
116        Ok(self.base.trim(keys, topive)?)
117    }
118
119    pub fn cnt_all(&self) -> Result<usize, SuberError> {
120        Ok(self.base.cnt_all()?)
121    }
122}
123
124/// CryptSignerSuber extends SignerSuber to add encryption and decryption capabilities
125///
126/// Data is stored as encrypted Signer instances if an encrypter is provided.
127/// On retrieval, the data is decrypted if a decrypter is provided.
128///
129/// Assumes that last or only element of db key from keys for all entries is the qb64
130/// of a public key for the associated Verfer instance. This allows returned
131/// Signer instance to have its .transferable property set correctly.
132pub struct CryptSignerSuber {
133    base: CesrSuberBase<Signer>,
134}
135
136impl CryptSignerSuber {
137    pub fn new(
138        db: Arc<LMDBer>,
139        subkey: &str,
140        sep: Option<u8>,
141        verify: bool,
142    ) -> Result<Self, SuberError> {
143        let base = CesrSuberBase::new(db, subkey, sep, verify)?;
144
145        Ok(Self { base })
146    }
147
148    // Delegate all methods to the base
149    pub fn pin<K: AsRef<[u8]>>(
150        &self,
151        keys: &[K],
152        val: &Signer,
153        encrypter: Option<Encrypter>,
154    ) -> Result<bool, SuberError> {
155        match encrypter {
156            Some(encrypter) => {
157                let val = encrypter.encrypt(None, Some(val), None)?;
158                let val_bytes = val.qb64b();
159                let key = self.base.to_key(keys, false);
160                Ok(self.base.set_val(&key, &val_bytes)?)
161            }
162            None => Ok(self.base.pin(keys, val)?),
163        }
164    }
165
166    // Delegate all methods to the base
167    pub fn put<K: AsRef<[u8]>>(
168        &self,
169        keys: &[K],
170        val: &Signer,
171        encrypter: Option<Encrypter>,
172    ) -> Result<bool, SuberError> {
173        match encrypter {
174            Some(encrypter) => {
175                let val = encrypter.encrypt(None, Some(val), None)?;
176                let val_bytes = val.qb64b();
177                let key = self.base.to_key(keys, false);
178                Ok(self.base.put_val(&key, &val_bytes)?)
179            }
180            None => Ok(self.base.put(keys, val)?),
181        }
182    }
183
184    pub fn get<K: AsRef<[u8]>>(
185        &self,
186        keys: &[K],
187        decrypter: Option<Decrypter>,
188    ) -> Result<Option<Signer>, SuberError> {
189        if keys.is_empty() {
190            return Err(SuberError::EmptyKeys);
191        }
192
193        // Get raw value from database
194        let key_result = self.base.get_full_item_iter(keys, false)?;
195        if key_result.is_empty() {
196            return Ok(None);
197        }
198
199        let (ikeys, raw_val) = &key_result[0];
200
201        // Get the verkey (last element of keys)
202        let verkey = if let Some(last_key) = ikeys.last() {
203            last_key
204        } else {
205            return Err(SuberError::EmptyKeys);
206        };
207        // Create Verfer from verkey to determine transferability
208        let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
209        let transferable = verfer.is_transferable();
210
211        match decrypter {
212            Some(decrypter) => {
213                // Create Signer with the correct transferable property
214                let qb64 = std::str::from_utf8(raw_val).map_err(|e| {
215                    SuberError::DecryptionError(format!("Invalid raw value: {}", e))
216                })?;
217                let signer = decrypter
218                    .decrypt(None, Some(qb64), None, Some(transferable), None)?
219                    .downcast::<Signer>()
220                    .map_err(|_| {
221                        SuberError::DecryptionError("Failed to downcast to Signer".to_string())
222                    })?;
223
224                Ok(Some(*signer))
225            }
226            None => {
227                // Create Signer with the correct transferable property
228                let mut qb64b = raw_val.clone();
229                let signer = Signer::from_qb64b_and_transferable(&mut qb64b, None, transferable)?;
230
231                Ok(Some(signer))
232            }
233        }
234    }
235
236    // Remove an entry at keys
237    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
238        self.base.rem(keys)
239    }
240
241    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
242        self.base.trim(keys, topive)
243    }
244
245    pub fn get_full_item_iter<K: AsRef<[u8]>>(
246        &self,
247        keys: &[K],
248        topive: bool,
249    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
250        self.base.get_full_item_iter(keys, topive)
251    }
252
253    /// Returns iterator over items in the subdb whose key starts with the provided keys
254    ///
255    /// # Arguments
256    /// * `keys` - Optional prefix keys to filter results
257    /// * `topive` - If true, treat as partial key tuple from top branch
258    ///
259    /// # Returns
260    /// * Vector of tuples containing (keys, signer instance)
261    pub fn get_item_iter<K: AsRef<[u8]>>(
262        &self,
263        keys: &[K],
264        topive: bool,
265        decrypter: Option<Decrypter>,
266    ) -> Result<Vec<(Vec<Vec<u8>>, Signer)>, SuberError> {
267        let items = self.base.get_full_item_iter(keys, topive)?;
268        let mut result = Vec::with_capacity(items.len());
269
270        for (ikeys, val) in items {
271            // Get verkey (last element of keys)
272            let verkey = if let Some(last_key) = ikeys.last() {
273                last_key
274            } else {
275                continue;
276            };
277
278            // Create Verfer from verkey to determine transferability
279            let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
280            let transferable = verfer.is_transferable();
281
282            // Create Signer with the correct transferable property
283            let signer = match &decrypter {
284                Some(decrypter) => {
285                    // Create Signer with the correct transferable property
286                    let qb64 = std::str::from_utf8(&val).map_err(|e| {
287                        SuberError::DecryptionError(format!("Invalid raw value: {}", e))
288                    })?;
289                    let boxed_signer = decrypter
290                        .decrypt(None, Some(qb64), None, Some(transferable), None)?
291                        .downcast::<Signer>()
292                        .map_err(|_| {
293                            SuberError::DecryptionError("Failed to downcast to Signer".to_string())
294                        })?;
295
296                    *boxed_signer
297                }
298                None => {
299                    // Create Signer with the correct transferable property
300                    let mut qb64b = val.clone();
301                    Signer::from_qb64b_and_transferable(&mut qb64b, None, transferable)?
302                }
303            };
304
305            result.push((ikeys, signer))
306        }
307
308        Ok(result)
309    }
310
311    pub fn process_items(
312        &self,
313        items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
314    ) -> Result<Vec<(Vec<Vec<u8>>, Signer)>, SuberError> {
315        self.base.process_items(items)
316    }
317
318    pub fn cnt_all(&self) -> Result<usize, SuberError> {
319        self.base.cnt_all()
320    }
321}
322
323#[cfg(test)]
324mod tests {
325    use super::*;
326    use crate::cesr::mtr_dex;
327    use crate::cesr::signing::{Salter, Signer};
328    use std::sync::Arc;
329
330    #[test]
331    fn test_signer_suber() -> Result<(), Box<dyn std::error::Error>> {
332        // Open LMDB database
333        let db = LMDBer::builder().name("test").temp(true).build()?;
334
335        // Ensure the database is opened correctly
336        assert_eq!(db.name(), "test");
337        assert!(db.opened());
338
339        let db_arc = Arc::new(db);
340
341        // Create SignerSuber with default Signer class
342        let sdb = SignerSuber::new(db_arc.clone(), "bags.", None, false)?;
343
344        // Verify dupsort is not set (this may need adjustment based on your implementation)
345        // Skip this assertion if your Rust implementation handles dupsort differently
346
347        // Create test seeds and signers
348        let seed0 = &[
349            0x18, 0x3b, 0x30, 0xc4, 0x0f, 0x2a, 0x76, 0x46, 0xfa, 0xe3, 0xa2, 0x45, 0x65, 0x65,
350            0x1f, 0x96, 0x6f, 0xce, 0x29, 0x47, 0x85, 0xe3, 0x58, 0x86, 0xda, 0x04, 0xf0, 0xdc,
351            0xde, 0x06, 0xc0, 0x2b,
352        ];
353
354        let signer0 = Signer::new(Some(seed0), Some(mtr_dex::ED25519_SEED), Some(true))?;
355        assert_eq!(signer0.verfer().code(), mtr_dex::ED25519);
356        assert!(signer0.verfer().is_transferable()); // default
357        assert_eq!(
358            signer0.qb64b(),
359            b"ABg7MMQPKnZG-uOiRWVlH5ZvzilHheNYhtoE8NzeBsAr"
360        );
361        assert_eq!(
362            signer0.verfer().qb64b(),
363            b"DIYsYWYwtVo9my0dUHQA0-_ZEts8B5XdvXpHGtHpcR4h"
364        );
365
366        let seed1 = &[
367            0x60, 0x05, 0x93, 0xb9, 0x9b, 0x36, 0x1e, 0xe0, 0xd7, 0x98, 0x5e, 0x94, 0xc8, 0x45,
368            0x74, 0xf2, 0xc4, 0xcd, 0x94, 0x18, 0xc6, 0xae, 0xb9, 0xb6, 0x6d, 0x12, 0xc4, 0x80,
369            0x03, 0x07, 0xfc, 0xf7,
370        ];
371
372        let signer1 = Signer::new(Some(seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
373        assert_eq!(signer1.verfer().code(), mtr_dex::ED25519);
374        assert!(signer1.verfer().is_transferable()); // default
375        assert_eq!(
376            signer1.qb64b(),
377            b"AGAFk7mbNh7g15helMhFdPLEzZQYxq65tm0SxIADB_z3"
378        );
379        assert_eq!(
380            signer1.verfer().qb64b(),
381            b"DIHpH-kgf2oMMfeplUmSOj0wtPY-EqfKlG4CoJTfLi42"
382        );
383
384        // Test put and get with keys
385        let keys = [signer0.verfer().qb64()];
386        let result = sdb.put(&keys, &signer0)?;
387        assert!(result);
388
389        let actual = sdb.get(&keys)?.unwrap();
390        assert_eq!(actual.qb64(), signer0.qb64());
391        assert_eq!(actual.verfer().qb64(), signer0.verfer().qb64());
392
393        // Test rem
394        sdb.trim(&keys, false)?;
395        let actual = sdb.get(&keys)?;
396        assert!(actual.is_none());
397
398        // Test put again
399        let result = sdb.put(&keys, &signer0)?;
400        assert!(result);
401
402        let actual = sdb.get(&keys)?.unwrap();
403        assert_eq!(actual.qb64(), signer0.qb64());
404        assert_eq!(actual.verfer().qb64(), signer0.verfer().qb64());
405
406        // Test put with different value when already put
407        // In the Rust implementation, we might expect put to return false if the key exists
408        let result = sdb.put(&keys, &signer1)?;
409        assert!(!result);
410
411        let actual = sdb.get(&keys)?.unwrap();
412        assert_eq!(actual.qb64(), signer0.qb64());
413        assert_eq!(actual.verfer().qb64(), signer0.verfer().qb64());
414
415        // Test pin (overwrite)
416        let result = sdb.pin(&keys, &signer1)?;
417        assert!(result);
418
419        let actual = sdb.get(&keys)?.unwrap();
420        assert_eq!(actual.qb64(), signer1.qb64());
421        assert_eq!(actual.verfer().qb64(), signer1.verfer().qb64());
422
423        // Test with keys as single string not array
424        let single_key = [signer0.verfer().qb64()];
425
426        let result = sdb.pin(&single_key, &signer0)?;
427        assert!(result);
428
429        let actual = sdb.get(&single_key)?.unwrap();
430        assert_eq!(actual.qb64(), signer0.qb64());
431        assert_eq!(actual.verfer().qb64(), signer0.verfer().qb64());
432
433        // Test rem again
434        sdb.trim(&single_key, false)?;
435        let actual = sdb.get(&single_key)?;
436        assert!(actual.is_none());
437
438        // Test missing entry
439        let bad_key = ["DAQdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE"];
440        let actual = sdb.get(&bad_key)?;
441        assert!(actual.is_none());
442
443        // Test iteritems with new suber instance
444        let sdb_new = SignerSuber::new(db_arc.clone(), "pugs.", None, false)?;
445
446        let result = sdb_new.put(&[signer0.verfer().qb64b()], &signer0)?;
447        assert!(result);
448
449        let result = sdb_new.put(&[signer1.verfer().qb64b()], &signer1)?;
450        assert!(result);
451
452        let empty: [&[u8]; 0] = [];
453        let items = sdb_new.get_item_iter(&empty, true)?;
454
455        // Convert items to comparable format for assertion
456        // Note: The order might be different from Python due to the nature of hash table iteration
457        // We'll sort the items to ensure a consistent comparison
458        let mut result_items: Vec<(String, String)> = items
459            .iter()
460            .map(|(keys, signer)| {
461                let key_joined = String::from_utf8(keys[0].clone()).unwrap();
462                (key_joined, signer.qb64())
463            })
464            .collect();
465
466        result_items.sort();
467
468        let mut expected_items = vec![
469            (signer0.verfer().qb64(), signer0.qb64()),
470            (signer1.verfer().qb64(), signer1.qb64()),
471        ];
472        expected_items.sort();
473
474        assert_eq!(result_items, expected_items);
475
476        // Test with composite keys
477        let result = sdb_new.put(&["a", signer0.verfer().qb64().as_str()], &signer0)?;
478        assert!(result);
479
480        let result = sdb_new.put(&["a", signer1.verfer().qb64().as_str()], &signer1)?;
481        assert!(result);
482
483        let result = sdb_new.put(&["ab", signer0.verfer().qb64().as_str()], &signer0)?;
484        assert!(result);
485
486        let result = sdb_new.put(&["ab", signer1.verfer().qb64().as_str()], &signer1)?;
487        assert!(result);
488
489        // Test iteration with topkeys
490        let top_keys = ["a", ""]; // append empty str to force trailing separator
491        let items = sdb_new.get_item_iter(&top_keys, true)?;
492
493        let mut result_items: Vec<(Vec<String>, String)> = items
494            .iter()
495            .map(|(keys, signer)| {
496                let key_strings: Vec<String> = keys
497                    .iter()
498                    .map(|k| String::from_utf8(k.clone()).unwrap())
499                    .collect();
500                (key_strings, signer.qb64())
501            })
502            .collect();
503
504        result_items.sort();
505
506        let mut expected_items = vec![
507            (
508                vec!["a".to_string(), signer0.verfer().qb64()],
509                signer0.qb64(),
510            ),
511            (
512                vec!["a".to_string(), signer1.verfer().qb64()],
513                signer1.qb64(),
514            ),
515        ];
516        expected_items.sort();
517
518        assert_eq!(result_items, expected_items);
519
520        // Close the database and check it's no longer open
521        drop(db_arc);
522
523        Ok(())
524    }
525
526    #[test]
527    fn test_crypt_signer_suber() -> Result<(), Box<dyn std::error::Error>> {
528        // Setup test signers
529        let seed0: Vec<u8> = vec![
530            0x18, 0x3b, 0x30, 0xc4, 0x0f, 0x2a, 0x76, 0x46, 0xfa, 0xe3, 0xa2, 0x45, 0x65, 0x65,
531            0x1f, 0x96, 0x6f, 0xce, 0x29, 0x47, 0x85, 0xe3, 0x58, 0x86, 0xda, 0x04, 0xf0, 0xdc,
532            0xde, 0x06, 0xc0, 0x2b,
533        ];
534        let signer0 = Signer::new(Some(&seed0), Some(mtr_dex::ED25519_SEED), Some(true))?;
535        assert_eq!(signer0.verfer.code(), mtr_dex::ED25519);
536        assert!(signer0.verfer.is_transferable()); // default
537        assert_eq!(
538            signer0.qb64(),
539            "ABg7MMQPKnZG-uOiRWVlH5ZvzilHheNYhtoE8NzeBsAr"
540        );
541        assert_eq!(
542            signer0.verfer.qb64(),
543            "DIYsYWYwtVo9my0dUHQA0-_ZEts8B5XdvXpHGtHpcR4h"
544        );
545
546        let seed1: Vec<u8> = vec![
547            0x60, 0x05, 0x93, 0xb9, 0x9b, 0x36, 0x1e, 0xe0, 0xd7, 0x98, 0x5e, 0x94, 0xc8, 0x45,
548            0x74, 0xf2, 0xc4, 0xcd, 0x94, 0x18, 0xc6, 0xae, 0xb9, 0xb6, 0x6d, 0x12, 0xc4, 0x80,
549            0x03, 0x07, 0xfc, 0xf7,
550        ];
551
552        let signer1 = Signer::new(Some(&seed1), Some(mtr_dex::ED25519_SEED), Some(true))?;
553        assert_eq!(signer1.verfer.code(), mtr_dex::ED25519);
554        assert!(signer1.verfer.is_transferable()); // default
555        assert_eq!(
556            signer1.qb64(),
557            "AGAFk7mbNh7g15helMhFdPLEzZQYxq65tm0SxIADB_z3"
558        );
559        assert_eq!(
560            signer1.verfer.qb64(),
561            "DIHpH-kgf2oMMfeplUmSOj0wtPY-EqfKlG4CoJTfLi42"
562        );
563
564        let rawsalt = b"0123456789abcdef".to_vec();
565        let salter = Salter::new(Some(&rawsalt), None, None)?;
566        let salt = salter.qb64();
567        assert_eq!(salt, "0AAwMTIzNDU2Nzg5YWJjZGVm");
568        let stem = "blue";
569
570        let cryptseed0: Vec<u8> = vec![
571            0x68, 0x2c, 0x23, 0x7c, 0x8a, 0x70, 0x22, 0x12, 0xc4, 0x33, 0x74, 0x32, 0xa6, 0xe1,
572            0x18, 0x19, 0xf0, 0x66, 0x32, 0x2c, 0x79, 0xc4, 0xc2, 0x31, 0x40, 0xf5, 0x40, 0x15,
573            0x2e, 0xa2, 0x1a, 0xcf,
574        ];
575        let cryptsigner0 =
576            Signer::new(Some(&cryptseed0), Some(mtr_dex::ED25519_SEED), Some(false))?;
577        let seed0 = cryptsigner0.qb64();
578        let aeid0 = cryptsigner0.verfer.qb64();
579        assert_eq!(aeid0, "BCa7mK96FwxkU0TdF54Yqg3qBDXUWpOhQ_Mtr7E77yZB");
580
581        let decrypter = Decrypter::new(Some(seed0.as_bytes()), None, None)?;
582        let encrypter = Encrypter::new(None, None, Some(aeid0.as_bytes()))?;
583        assert!(encrypter.verify_seed(seed0.as_bytes())?);
584
585        let cryptseed1: Vec<u8> = vec![
586            0x89, 0xfe, 0x7b, 0xd9, 0x27, 0xa7, 0xb3, 0x89, 0x23, 0x19, 0xbe, 0x63, 0xee, 0xed,
587            0xc0, 0xf9, 0x97, 0xd0, 0x8f, 0x39, 0x1d, 0x79, 0x4e, 0x49, 0x49, 0x98, 0xbd, 0xa4,
588            0xf6, 0xfe, 0xbb, 0x03,
589        ];
590        let cryptsigner1 =
591            Signer::new(Some(&cryptseed1), Some(mtr_dex::ED25519_SEED), Some(false))?;
592
593        // Create temporary directory for the LMDB database
594        // Open LMDB database
595        // Open LMDB database
596        let db = LMDBer::builder().name("test").temp(true).build()?;
597
598        let db_arc = Arc::new(db);
599
600        // Test CryptSignerSuber functionality
601        {
602            // Create a CryptSignerSuber instance
603            let sdb = CryptSignerSuber::new(db_arc.clone(), "bags.", None, true)?;
604
605            // Test without encrypter or decrypter
606            let vqb64 = signer0.verfer.qb64();
607            let keys = &[vqb64.as_bytes()];
608
609            // Test put and get
610            assert!(sdb.put(keys, &signer0, None)?);
611            let actual = sdb.get(keys, None)?.unwrap();
612            assert_eq!(actual.qb64(), signer0.qb64());
613            assert_eq!(actual.verfer.qb64(), signer0.verfer.qb64());
614
615            // Test remove
616            assert!(sdb.rem(keys)?);
617            assert!(sdb.get(keys, None)?.is_none());
618
619            // Test put again
620            assert!(sdb.put(keys, &signer0, None)?);
621            let actual = sdb.get(keys, None)?.unwrap();
622            assert_eq!(actual.qb64(), signer0.qb64());
623            assert_eq!(actual.verfer.qb64(), signer0.verfer.qb64());
624
625            // Try putting a different value when already present
626            let result = sdb.put(keys, &signer1, None)?;
627            assert!(!result);
628            let actual = sdb.get(keys, None)?.unwrap();
629            assert_eq!(actual.qb64(), signer0.qb64());
630            assert_eq!(actual.verfer.qb64(), signer0.verfer.qb64());
631
632            // Test pin to overwrite
633            assert!(sdb.pin(keys, &signer1, None)?);
634            let actual = sdb.get(keys, None)?.unwrap();
635            assert_eq!(actual.qb64(), signer1.qb64());
636            assert_eq!(actual.verfer.qb64(), signer1.verfer.qb64());
637
638            // Test with key as single string
639            let key_str = signer0.verfer.qb64();
640            let keys = &[key_str.as_bytes()];
641
642            assert!(sdb.pin(keys, &signer0, None)?);
643            let actual = sdb.get(keys, None)?.unwrap();
644            assert_eq!(actual.qb64(), signer0.qb64());
645            assert_eq!(actual.verfer.qb64(), signer0.verfer.qb64());
646
647            assert!(sdb.rem(keys)?);
648            assert!(sdb.get(keys, None)?.is_none());
649
650            // Test missing entry
651            let bad_key = "D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE";
652            assert!(sdb.get(&[bad_key.as_bytes()], None)?.is_none());
653        }
654
655        // Test iteritems
656        {
657            let sdb = CryptSignerSuber::new(db_arc.clone(), "pugs.", None, true)?;
658
659            assert!(sdb.put(&[signer0.verfer.qb64().as_bytes()], &signer0, None)?);
660            assert!(sdb.put(&[signer1.verfer.qb64().as_bytes()], &signer1, None)?);
661
662            let items = sdb.get_item_iter(&[] as &[&[u8]], false, None)?;
663            let mut items_qb64 = items
664                .iter()
665                .map(|(keys, sgnr)| {
666                    let key_strs: Vec<String> = keys
667                        .iter()
668                        .map(|k| String::from_utf8(k.clone()).unwrap())
669                        .collect();
670                    (key_strs, sgnr.qb64())
671                })
672                .collect::<Vec<_>>();
673
674            // Sort for predictable order in test
675            items_qb64.sort_by(|a, b| b.0[0].cmp(&a.0[0]));
676
677            assert_eq!(items_qb64.len(), 2);
678            assert_eq!(items_qb64[0].0[0], signer0.verfer.qb64());
679            assert_eq!(items_qb64[0].1, signer0.qb64());
680            assert_eq!(items_qb64[1].0[0], signer1.verfer.qb64());
681            assert_eq!(items_qb64[1].1, signer1.qb64());
682
683            // Now test with encrypter and decrypter
684            let encrypter0 = Encrypter::new(None, None, Some(&cryptsigner0.verfer.qb64b()))?;
685            let decrypter0 = Decrypter::new(None, None, Some(&cryptsigner0.qb64b()))?;
686
687            // First pin with encrypter
688            assert!(sdb.pin(
689                &[signer0.verfer.qb64().as_bytes()],
690                &signer0,
691                Some(encrypter0.clone())
692            )?);
693            assert!(sdb.pin(
694                &[signer1.verfer.qb64().as_bytes()],
695                &signer1,
696                Some(encrypter0.clone())
697            )?);
698
699            // Now get with decrypter
700            let actual0 = sdb
701                .get(
702                    &[signer0.verfer.qb64().as_bytes()],
703                    Some(decrypter0.clone()),
704                )?
705                .unwrap();
706            assert_eq!(actual0.qb64(), signer0.qb64());
707            assert_eq!(actual0.verfer.qb64(), signer0.verfer.qb64());
708
709            let actual1 = sdb
710                .get(
711                    &[signer1.verfer.qb64().as_bytes()],
712                    Some(decrypter0.clone()),
713                )?
714                .unwrap();
715            assert_eq!(actual1.qb64(), signer1.qb64());
716            assert_eq!(actual1.verfer.qb64(), signer1.verfer.qb64());
717
718            // Now try to get without decrypter - should fail
719            match sdb.get(&[signer0.verfer.qb64().as_bytes()], None) {
720                Err(_) => assert!(true),
721                Ok(_) => assert!(false, "Should fail without decrypter"),
722            }
723
724            match sdb.get(&[signer1.verfer.qb64().as_bytes()], None) {
725                Err(_) => assert!(true),
726                Ok(_) => assert!(false, "Should fail without decrypter"),
727            }
728
729            // Remove and test put
730            assert!(sdb.rem(&[signer0.verfer.qb64b()])?);
731            assert!(sdb
732                .get(&[signer0.verfer.qb64b()], Some(decrypter0.clone()))?
733                .is_none());
734
735            assert!(sdb.rem(&[signer1.verfer.qb64b()])?);
736            assert!(sdb
737                .get(&[signer1.verfer.qb64b()], Some(decrypter0.clone()))?
738                .is_none());
739
740            assert!(sdb.put(
741                &[signer0.verfer.qb64b()],
742                &signer0,
743                Some(encrypter0.clone())
744            )?);
745            assert!(sdb.put(
746                &[signer1.verfer.qb64b()],
747                &signer1,
748                Some(encrypter0.clone())
749            )?);
750
751            // Test getItemIter with decrypter
752            let items = sdb.get_item_iter(&[] as &[&[u8]], false, Some(decrypter0.clone()))?;
753            let mut items_qb64 = items
754                .iter()
755                .map(|(keys, sgnr)| {
756                    let key_strs: Vec<String> = keys
757                        .iter()
758                        .map(|k| String::from_utf8(k.clone()).unwrap())
759                        .collect();
760                    (key_strs, sgnr.qb64())
761                })
762                .collect::<Vec<_>>();
763
764            // Sort for predictable order in test
765            items_qb64.sort_by(|a, b| b.0[0].cmp(&a.0[0]));
766
767            assert_eq!(items_qb64.len(), 2);
768            assert_eq!(items_qb64[0].0[0], signer0.verfer.qb64());
769            assert_eq!(items_qb64[0].1, signer0.qb64());
770            assert_eq!(items_qb64[1].0[0], signer1.verfer.qb64());
771            assert_eq!(items_qb64[1].1, signer1.qb64());
772
773            // Test composite keys
774            assert!(sdb.put(
775                &["a".as_bytes(), signer0.verfer.qb64().as_bytes()],
776                &signer0,
777                Some(encrypter0.clone())
778            )?);
779            assert!(sdb.put(
780                &["a".as_bytes(), signer1.verfer.qb64().as_bytes()],
781                &signer1,
782                Some(encrypter0.clone())
783            )?);
784            assert!(sdb.put(
785                &["ab".as_bytes(), signer0.verfer.qb64().as_bytes()],
786                &signer0,
787                Some(encrypter0.clone())
788            )?);
789            assert!(sdb.put(
790                &["ab".as_bytes(), signer1.verfer.qb64().as_bytes()],
791                &signer1,
792                Some(encrypter0.clone())
793            )?);
794
795            // Test prefix iteration
796            let top_keys = &["a".as_bytes(), "".as_bytes()]; // append empty str to force trailing .sep
797            let items = sdb.get_item_iter(top_keys, true, Some(decrypter0.clone()))?;
798
799            let items_qb64 = items
800                .iter()
801                .map(|(keys, sgnr)| {
802                    let key_strs: Vec<String> = keys
803                        .iter()
804                        .map(|k| String::from_utf8(k.clone()).unwrap())
805                        .collect();
806                    (key_strs, sgnr.qb64())
807                })
808                .collect::<Vec<_>>();
809
810            assert_eq!(items_qb64.len(), 2);
811            // Check that we have both signer0 and signer1 with prefix "a"
812            let has_signer0 = items_qb64.iter().any(|(keys, qb64)| {
813                keys[0] == "a" && keys[1] == signer0.verfer.qb64() && *qb64 == signer0.qb64()
814            });
815            let has_signer1 = items_qb64.iter().any(|(keys, qb64)| {
816                keys[0] == "a" && keys[1] == signer1.verfer.qb64() && *qb64 == signer1.qb64()
817            });
818            assert!(has_signer0);
819            assert!(has_signer1);
820
821            // Test re-encrypt
822            let encrypter1 =
823                Encrypter::new(None, None, Some(cryptsigner1.verfer.qb64().as_bytes()))?;
824            let decrypter1 = Decrypter::new(None, None, Some(cryptsigner1.qb64().as_bytes()))?;
825
826            for (keys, sgnr) in
827                sdb.get_item_iter(&[] as &[&[u8]], false, Some(decrypter0.clone()))?
828            {
829                sdb.pin(
830                    &keys.iter().map(|k| k.as_slice()).collect::<Vec<_>>(),
831                    &sgnr,
832                    Some(encrypter1.clone()),
833                )?;
834            }
835
836            // Verify re-encrypted data is accessible with new decrypter
837            let items = sdb.get_item_iter(&[] as &[&[u8]], false, Some(decrypter1))?;
838            assert_eq!(items.len(), 6); // Should have all 6 items
839
840            // Verify we can find all the expected entries
841            let items_map: std::collections::HashMap<String, Vec<(Vec<String>, String)>> = items
842                .iter()
843                .map(|(keys, sgnr)| {
844                    let key_strs: Vec<String> = keys
845                        .iter()
846                        .map(|k| String::from_utf8(k.clone()).unwrap())
847                        .collect();
848                    let prefix = if key_strs.len() > 1 {
849                        key_strs[0].clone()
850                    } else {
851                        "root".to_string()
852                    };
853                    (prefix, (key_strs, sgnr.qb64()))
854                })
855                .fold(
856                    std::collections::HashMap::new(),
857                    |mut acc, (prefix, entry)| {
858                        acc.entry(prefix).or_insert_with(Vec::new).push(entry);
859                        acc
860                    },
861                );
862
863            // Verify the expected entries
864            assert_eq!(items_map.get("root").unwrap().len(), 2);
865            assert_eq!(items_map.get("a").unwrap().len(), 2);
866            assert_eq!(items_map.get("ab").unwrap().len(), 2);
867        }
868
869        Ok(())
870    }
871}