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 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 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 let verkey = if let Some(last_key) = ikeys.last() {
52 last_key
53 } else {
54 return Err(SuberError::EmptyKeys);
55 };
56
57 let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
59 let transferable = verfer.is_transferable();
60
61 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 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 let verkey = if let Some(last_key) = ikeys.last() {
87 last_key
88 } else {
89 continue;
90 };
91
92 let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
94 let transferable = verfer.is_transferable();
95
96 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 pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &Signer) -> Result<bool, SuberError> {
107 Ok(self.base.put(keys, val)?)
108 }
109
110 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
124pub 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 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 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 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 let verkey = if let Some(last_key) = ikeys.last() {
203 last_key
204 } else {
205 return Err(SuberError::EmptyKeys);
206 };
207 let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
209 let transferable = verfer.is_transferable();
210
211 match decrypter {
212 Some(decrypter) => {
213 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 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 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 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 let verkey = if let Some(last_key) = ikeys.last() {
273 last_key
274 } else {
275 continue;
276 };
277
278 let verfer = Verfer::from_qb64b(&mut verkey.clone(), None)?;
280 let transferable = verfer.is_transferable();
281
282 let signer = match &decrypter {
284 Some(decrypter) => {
285 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 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 let db = LMDBer::builder().name("test").temp(true).build()?;
334
335 assert_eq!(db.name(), "test");
337 assert!(db.opened());
338
339 let db_arc = Arc::new(db);
340
341 let sdb = SignerSuber::new(db_arc.clone(), "bags.", None, false)?;
343
344 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()); 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()); 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 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 sdb.trim(&keys, false)?;
395 let actual = sdb.get(&keys)?;
396 assert!(actual.is_none());
397
398 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 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 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 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 sdb.trim(&single_key, false)?;
435 let actual = sdb.get(&single_key)?;
436 assert!(actual.is_none());
437
438 let bad_key = ["DAQdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE"];
440 let actual = sdb.get(&bad_key)?;
441 assert!(actual.is_none());
442
443 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 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 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 let top_keys = ["a", ""]; 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 drop(db_arc);
522
523 Ok(())
524 }
525
526 #[test]
527 fn test_crypt_signer_suber() -> Result<(), Box<dyn std::error::Error>> {
528 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()); 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()); 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 let db = LMDBer::builder().name("test").temp(true).build()?;
597
598 let db_arc = Arc::new(db);
599
600 {
602 let sdb = CryptSignerSuber::new(db_arc.clone(), "bags.", None, true)?;
604
605 let vqb64 = signer0.verfer.qb64();
607 let keys = &[vqb64.as_bytes()];
608
609 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 assert!(sdb.rem(keys)?);
617 assert!(sdb.get(keys, None)?.is_none());
618
619 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 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 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 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 let bad_key = "D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE";
652 assert!(sdb.get(&[bad_key.as_bytes()], None)?.is_none());
653 }
654
655 {
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 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 let encrypter0 = Encrypter::new(None, None, Some(&cryptsigner0.verfer.qb64b()))?;
685 let decrypter0 = Decrypter::new(None, None, Some(&cryptsigner0.qb64b()))?;
686
687 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 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 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 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 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 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 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 let top_keys = &["a".as_bytes(), "".as_bytes()]; 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 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 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 let items = sdb.get_item_iter(&[] as &[&[u8]], false, Some(decrypter1))?;
838 assert_eq!(items.len(), 6); 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 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}