Skip to main content

libkeri/keri/db/subing/
catcesr.rs

1use crate::cesr::cigar::Cigar;
2use crate::cesr::dater::Dater;
3use crate::cesr::diger::Diger;
4use crate::cesr::indexing::siger::Siger;
5use crate::cesr::number::Number;
6use crate::cesr::prefixer::Prefixer;
7use crate::cesr::saider::Saider;
8use crate::cesr::seqner::Seqner;
9use crate::cesr::verfer::Verfer;
10use crate::cesr::{BaseMatter, Parsable};
11use crate::keri::db::dbing::LMDBer;
12use crate::keri::db::subing::cesr::CesrSuberBase;
13use crate::keri::db::subing::{Suber, SuberError};
14use crate::Matter;
15use std::sync::Arc;
16
17pub struct CatCesrSuberBase<M: Matter> {
18    pub base: CesrSuberBase<M>,
19    pub formats: Vec<String>,
20}
21
22impl<M: Matter + Parsable> CatCesrSuberBase<M> {
23    /// Creates a new CatCesrSuberBase
24    ///
25    /// Parameters:
26    ///   - db: The base LMDB database
27    ///   - subkey: The key for the sub-database
28    ///   - formats: Array of format strings that determine which serialization/deserialization methods to use
29    ///   - sep: Optional separator for keys
30    ///   - verify: Whether to verify data when deserializing
31    pub fn new(
32        db: Arc<LMDBer>,
33        subkey: &str,
34        formats: Vec<String>,
35        sep: Option<u8>,
36        verify: bool,
37    ) -> Result<Self, SuberError> {
38        let base = CesrSuberBase::new(db, subkey, sep, verify)?;
39
40        Ok(Self { base, formats })
41    }
42
43    /// Generic serialization dispatch method that handles any Matter type
44    /// but with specific logic for the supported format types
45    pub fn ser(&self, val: &[&dyn Matter]) -> Result<Vec<u8>, SuberError> {
46        match self.formats.as_slice() {
47            // Handle siger format
48            [a] if a == "siger" => {
49                // Validate we have exactly 1 value
50                if val.len() != 1 {
51                    return Err(SuberError::ValueConversionError(
52                        "Expected 1 value for siger format".to_string(),
53                    ));
54                }
55
56                let siger = match val[0].as_any().downcast_ref::<Siger>() {
57                    Some(s) => s,
58                    None => {
59                        return Err(SuberError::ValueConversionError(
60                            "Value must be a Siger".to_string(),
61                        ))
62                    }
63                };
64
65                self.ser_from_siger(siger)
66            }
67
68            // Handle seqner, saider format
69            [a, b] if a == "seqner" && b == "saider" => {
70                if val.len() != 2 {
71                    return Err(SuberError::ValueConversionError(
72                        "Expected 2 values for seqner saider format".to_string(),
73                    ));
74                }
75                self.ser_from_seqner_saider(val[0], val[1])
76            }
77
78            // Handle verfer, cigar format
79            [a, b] if a == "verfer" && b == "cigar" => {
80                if val.len() != 2 {
81                    return Err(SuberError::ValueConversionError(
82                        "Expected 2 values for verfer cigar format".to_string(),
83                    ));
84                }
85                self.ser_from_verfer_cigar(val[0], val[1])
86            }
87
88            // Handle number, saider format
89            [a, b] if a == "number" && b == "saider" => {
90                if val.len() != 2 {
91                    return Err(SuberError::ValueConversionError(
92                        "Expected 2 values for number saider format".to_string(),
93                    ));
94                }
95                self.ser_from_number_saider(val[0], val[1])
96            }
97
98            // Handle prefixer, seqner format
99            [a, b] if a == "prefixer" && b == "seqner" => {
100                if val.len() != 2 {
101                    return Err(SuberError::ValueConversionError(
102                        "Expected 2 values for prefixer seqner format".to_string(),
103                    ));
104                }
105                self.ser_from_prefixer_seqner(val[0], val[1])
106            }
107
108            // Handle seqner, diger format
109            [a, b] if a == "seqner" && b == "diger" => {
110                if val.len() != 2 {
111                    return Err(SuberError::ValueConversionError(
112                        "Expected 2 values for seqner diger format".to_string(),
113                    ));
114                }
115                self.ser_from_seqner_diger(val[0], val[1])
116            }
117
118            // Handle dater, seqner, diger format
119            [a, b, c] if a == "dater" && b == "seqner" && c == "diger" => {
120                // Validate we have exactly 3 values
121                if val.len() != 3 {
122                    return Err(SuberError::ValueConversionError(
123                        "Expected 3 values for dater, seqner, diger format".to_string(),
124                    ));
125                }
126
127                self.ser_from_dater_seqner_diger(val[0], val[1], val[2])
128            }
129
130            // Handle prefixer, seqner, saider format
131            [a, b, c] if a == "prefixer" && b == "seqner" && c == "saider" => {
132                // Validate we have exactly 3 values
133                if val.len() != 3 {
134                    return Err(SuberError::ValueConversionError(
135                        "Expected 3 values for prefixer, seqner, diger format".to_string(),
136                    ));
137                }
138
139                self.ser_from_prefixer_seqner_saider(val[0], val[1], val[2])
140            }
141
142            // Default case - handle any Matter object
143            _ => {
144                // Serialize directly using qb64b
145                Ok(val[0].qb64b())
146            }
147        }
148    }
149
150    /// Generic deserialization dispatch method that handles any Matter type
151    /// but with specific logic for the supported format types
152    pub fn des(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
153        match self.formats.as_slice() {
154            // Handle siger format
155            [a] if a == "siger" => self.des_to_siger(val),
156
157            // Handle seqner saider format
158            [a, b] if a == "seqner" && b == "saider" => self.des_to_seqner_saider(val),
159
160            // Handle seqner diger format
161            [a, b] if a == "seqner" && b == "diger" => self.des_to_seqner_diger(val),
162
163            // Handle verfer cigar format
164            [a, b] if a == "verfer" && b == "cigar" => self.des_to_verfer_cigar(val),
165
166            // Handle number saider format
167            [a, b] if a == "number" && b == "saider" => self.des_to_number_saider(val),
168
169            // Handle prefixer seqner format
170            [a, b] if a == "prefixer" && b == "seqner" => self.des_to_prefixer_seqner(val),
171
172            // Handle dater, seqner, diger format
173            [a, b, c] if a == "dater" && b == "seqner" && c == "diger" => {
174                self.des_to_dater_seqner_diger(val)
175            }
176
177            // Handle prefixer, seqner, saider format
178            [a, b, c] if a == "prefixer" && b == "seqner" && c == "saider" => {
179                self.des_to_prefixer_seqner_saider(val)
180            }
181
182            // Default case - handle any Matter using BaseMatter
183            _ => {
184                // For generic format, deserialize as BaseMatter
185                let matter = BaseMatter::from_qb64b(&mut val.to_vec(), None)
186                    .map_err(|e| SuberError::MatterError(e))?;
187
188                // Return as a boxed Matter trait object
189                let boxed: Box<dyn Matter> = Box::new(matter);
190                Ok(vec![boxed])
191            }
192        }
193    }
194
195    /// Serializes from a Siger to bytes
196    pub fn ser_from_siger(&self, siger: &Siger) -> Result<Vec<u8>, SuberError> {
197        Ok(siger.qb64b())
198    }
199
200    /// Deserializes from bytes to a Siger
201    pub fn des_to_siger(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
202        // Convert val to a mutable vector so we can use from_qb64b
203        let mut data = val.to_vec();
204
205        // Parse the Siger
206        let siger = Siger::from_qb64b(&mut data, Some(true)).map_err(|e| {
207            SuberError::DeserializationError(format!("Failed to parse Siger: {}", e))
208        })?;
209
210        // Return as a vector of boxed Matter traits
211        let result: Vec<Box<dyn Matter>> = vec![Box::new(siger)];
212
213        Ok(result)
214    }
215
216    /// Serializes from a tuple of (Seqner, Saider) to bytes
217    pub fn ser_from_seqner_saider(
218        &self,
219        seqner: &dyn Matter,
220        saider: &dyn Matter,
221    ) -> Result<Vec<u8>, SuberError> {
222        // Concatenate the qb64b of each instance
223        let mut result = Vec::new();
224        result.extend_from_slice(&seqner.qb64b());
225        result.extend_from_slice(&saider.qb64b());
226
227        Ok(result)
228    }
229
230    /// Deserializes from bytes to a tuple of (Seqner, Saider)
231    pub fn des_to_seqner_saider(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
232        // Convert val to a mutable vector so we can use from_qb64b
233        let mut data = val.to_vec();
234
235        // Parse the Seqner
236        let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
237            SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
238        })?;
239
240        // Parse the Saider
241        let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
242            SuberError::DeserializationError(format!("Failed to parse Saider: {}", e))
243        })?;
244
245        let result: Vec<Box<dyn Matter>> = vec![Box::new(seqner), Box::new(saider)];
246
247        Ok(result)
248    }
249
250    /// Serializes from a tuple of (Verfer, Cigar) to bytes
251    pub fn ser_from_verfer_cigar(
252        &self,
253        verfer: &dyn Matter,
254        cigar: &dyn Matter,
255    ) -> Result<Vec<u8>, SuberError> {
256        // Concatenate the qb64b of each instance
257        let mut result = Vec::new();
258        result.extend_from_slice(&verfer.qb64b());
259        result.extend_from_slice(&cigar.qb64b());
260
261        Ok(result)
262    }
263
264    /// Deserializes from bytes to a tuple of (Verfer, Cigar)
265    pub fn des_to_verfer_cigar(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
266        // Convert val to a mutable vector so we can use from_qb64b
267        let mut data = val.to_vec();
268
269        // Parse the Verfer
270        let verfer = Verfer::from_qb64b(&mut data, Some(true)).map_err(|e| {
271            SuberError::DeserializationError(format!("Failed to parse Verfer: {}", e))
272        })?;
273
274        // Parse the Cigar
275        let cigar = Cigar::from_qb64b(&mut data, Some(true)).map_err(|e| {
276            SuberError::DeserializationError(format!("Failed to parse Cigar: {}", e))
277        })?;
278
279        let result: Vec<Box<dyn Matter>> = vec![Box::new(verfer), Box::new(cigar)];
280
281        Ok(result)
282    }
283
284    /// Serializes from a tuple of (Number, Saider) to bytes
285    pub fn ser_from_number_saider(
286        &self,
287        number: &dyn Matter,
288        saider: &dyn Matter,
289    ) -> Result<Vec<u8>, SuberError> {
290        // Concatenate the qb64b of each instance
291        let mut result = Vec::new();
292        result.extend_from_slice(&number.qb64b());
293        result.extend_from_slice(&saider.qb64b());
294
295        Ok(result)
296    }
297
298    /// Deserializes from bytes to a tuple of (Number, Saider)
299    pub fn des_to_number_saider(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
300        // Convert val to a mutable vector so we can use from_qb64b
301        let mut data = val.to_vec();
302
303        // Parse the Number
304        let number = Number::from_qb64b(&mut data, Some(true)).map_err(|e| {
305            SuberError::DeserializationError(format!("Failed to parse Number: {}", e))
306        })?;
307
308        // Parse the Saider
309        let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
310            SuberError::DeserializationError(format!("Failed to parse Saider: {}", e))
311        })?;
312
313        let result: Vec<Box<dyn Matter>> = vec![Box::new(number), Box::new(saider)];
314
315        Ok(result)
316    }
317
318    /// Serializes from a tuple of (Prefixer, Seqner) to bytes
319    pub fn ser_from_prefixer_seqner(
320        &self,
321        prefixer: &dyn Matter,
322        seqner: &dyn Matter,
323    ) -> Result<Vec<u8>, SuberError> {
324        // Concatenate the qb64b of each instance
325        let mut result = Vec::new();
326        result.extend_from_slice(&prefixer.qb64b());
327        result.extend_from_slice(&seqner.qb64b());
328
329        Ok(result)
330    }
331
332    /// Deserializes from bytes to a tuple of (Prefixer, Seqner)
333    pub fn des_to_prefixer_seqner(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
334        // Convert val to a mutable vector so we can use from_qb64b
335        let mut data = val.to_vec();
336
337        // Parse the Prefixer
338        let prefixer = Prefixer::from_qb64b(&mut data, Some(true)).map_err(|e| {
339            SuberError::DeserializationError(format!("Failed to parse Prefixer: {}", e))
340        })?;
341
342        // Parse the Seqner
343        let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
344            SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
345        })?;
346
347        let result: Vec<Box<dyn Matter>> = vec![Box::new(prefixer), Box::new(seqner)];
348
349        Ok(result)
350    }
351
352    /// Serializes from a tuple of (Seqner, Diger) to bytes
353    pub fn ser_from_seqner_diger(
354        &self,
355        seqner: &dyn Matter,
356        diger: &dyn Matter,
357    ) -> Result<Vec<u8>, SuberError> {
358        // Concatenate the qb64b of each instance
359        let mut result = Vec::new();
360        result.extend_from_slice(&seqner.qb64b());
361        result.extend_from_slice(&diger.qb64b());
362
363        Ok(result)
364    }
365
366    /// Deserializes from bytes to a tuple of (Seqner, Diger)
367    pub fn des_to_seqner_diger(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
368        // Convert val to a mutable vector so we can use from_qb64b
369        let mut data = val.to_vec();
370
371        // Parse the Seqner
372        let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
373            SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
374        })?;
375
376        // Parse the Diger
377        let diger = Diger::from_qb64b(&mut data, Some(true)).map_err(|e| {
378            SuberError::DeserializationError(format!("Failed to parse Diger: {}", e))
379        })?;
380
381        let result: Vec<Box<dyn Matter>> = vec![Box::new(seqner), Box::new(diger)];
382
383        Ok(result)
384    }
385
386    /// Serializes from a tuple of (Dater, Seqner, Diger) to bytes
387    pub fn ser_from_dater_seqner_diger(
388        &self,
389        dater: &dyn Matter,
390        seqner: &dyn Matter,
391        diger: &dyn Matter,
392    ) -> Result<Vec<u8>, SuberError> {
393        // Concatenate the qb64b of each instance
394        let mut result = Vec::new();
395        result.extend_from_slice(&dater.qb64b());
396        result.extend_from_slice(&seqner.qb64b());
397        result.extend_from_slice(&diger.qb64b());
398
399        Ok(result)
400    }
401
402    /// Deserializes from bytes to a tuple of (Dater, Seqner, Diger)
403    pub fn des_to_dater_seqner_diger(
404        &self,
405        val: &[u8],
406    ) -> Result<Vec<Box<dyn Matter>>, SuberError> {
407        // Convert val to a mutable vector so we can use from_qb64b
408        let mut data = val.to_vec();
409
410        // Parse the Dater
411        let dater = Dater::from_qb64b(&mut data, Some(true)).map_err(|e| {
412            SuberError::DeserializationError(format!("Failed to parse Dater: {}", e))
413        })?;
414
415        // Parse the Seqner
416        let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
417            SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
418        })?;
419
420        // Parse the Diger
421        let diger = Diger::from_qb64b(&mut data, Some(true)).map_err(|e| {
422            SuberError::DeserializationError(format!("Failed to parse Diger: {}", e))
423        })?;
424
425        let result: Vec<Box<dyn Matter>> = vec![Box::new(dater), Box::new(seqner), Box::new(diger)];
426
427        Ok(result)
428    }
429
430    /// Serializes from a tuple of (Dater, Seqner, Diger) to bytes
431    pub fn ser_from_prefixer_seqner_saider(
432        &self,
433        prefixer: &dyn Matter,
434        seqner: &dyn Matter,
435        saider: &dyn Matter,
436    ) -> Result<Vec<u8>, SuberError> {
437        // Concatenate the qb64b of each instance
438        let mut result = Vec::new();
439        result.extend_from_slice(&prefixer.qb64b());
440        result.extend_from_slice(&seqner.qb64b());
441        result.extend_from_slice(&saider.qb64b());
442
443        Ok(result)
444    }
445
446    /// Deserializes from bytes to a tuple of (Dater, Seqner, Diger)
447    pub fn des_to_prefixer_seqner_saider(
448        &self,
449        val: &[u8],
450    ) -> Result<Vec<Box<dyn Matter>>, SuberError> {
451        // Convert val to a mutable vector so we can use from_qb64b
452        let mut data = val.to_vec();
453
454        // Parse the Prefixer
455        let prefixer = Prefixer::from_qb64b(&mut data, Some(true)).map_err(|e| {
456            SuberError::DeserializationError(format!("Failed to parse prefixer: {}", e))
457        })?;
458
459        // Parse the Seqner
460        let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
461            SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
462        })?;
463
464        // Parse the Saider
465        let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
466            SuberError::DeserializationError(format!("Failed to parse saider: {}", e))
467        })?;
468
469        let result: Vec<Box<dyn Matter>> =
470            vec![Box::new(prefixer), Box::new(seqner), Box::new(saider)];
471
472        Ok(result)
473    }
474}
475
476/// CatCesrSuber is a wrapper around CatCesrSuberBase that provides the complete Suber interface
477
478pub struct CatCesrSuber<M: Matter> {
479    pub base: CatCesrSuberBase<M>,
480    pub suber: Suber,
481}
482
483impl<M: Matter + Parsable> CatCesrSuber<M> {
484    /// Creates a new CatCesrSuber
485    ///
486    /// Parameters:
487    ///   - db: The base LMDB database
488    ///   - subkey: The key for the sub-database
489    ///   - formats: Array of format strings that determine which serialization/deserialization methods to use
490    ///   - sep: Optional separator for keys
491    ///   - verify: Whether to verify data when deserializing
492    pub fn new(
493        db: Arc<LMDBer>,
494        subkey: &str,
495        formats: Vec<String>,
496        sep: Option<u8>,
497        verify: bool,
498    ) -> Result<Self, SuberError> {
499        let base = CatCesrSuberBase::new(db.clone(), subkey, formats, sep, verify)?;
500        let suber = Suber::new(db, subkey, sep, verify)?;
501
502        Ok(Self { base, suber })
503    }
504
505    // Delegate to the suber.put method
506    pub fn put<K: AsRef<[u8]>>(
507        &self,
508        keys: &[K],
509        vals: &[&dyn Matter],
510    ) -> Result<bool, SuberError> {
511        // Serialize Matter values to Vec<u8> using base.ser
512        let val_bytes = self.base.ser(vals)?;
513        // Then delegate to suber.put
514        self.suber.put(keys, &val_bytes)
515    }
516
517    // Delegate to the suber.pin method
518    pub fn pin<K: AsRef<[u8]>>(
519        &self,
520        keys: &[K],
521        vals: &[&dyn Matter],
522    ) -> Result<bool, SuberError> {
523        // Serialize Matter values to Vec<u8> using base.ser
524        let val_bytes = self.base.ser(vals)?;
525        // Then delegate to suber.pin
526        self.suber.pin(keys, &val_bytes)
527    }
528
529    // Delegate to the suber.get method
530    pub fn get<K: AsRef<[u8]>>(
531        &self,
532        keys: &[K],
533    ) -> Result<Option<Vec<Box<dyn Matter>>>, SuberError> {
534        // Get the value as Vec<u8> from suber
535        let val_opt = self.suber.get::<K, Vec<u8>>(keys)?;
536
537        // If value exists, deserialize it to Vec<Box<dyn Matter>>
538        match val_opt {
539            Some(val_bytes) => {
540                let deserialized = self.base.des(&val_bytes)?;
541                Ok(Some(deserialized))
542            }
543            None => Ok(None),
544        }
545    }
546
547    /// Removes a value from the database
548    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
549        self.suber.rem(keys)
550    }
551
552    /// Trims keys in the database
553    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
554        self.suber.trim(keys, topive)
555    }
556
557    /// Gets all items for a set of keys
558    pub fn get_full_item_iter<K: AsRef<[u8]>>(
559        &self,
560        keys: &[K],
561        topive: bool,
562    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
563        self.suber.base.get_full_item_iter(keys, topive)
564    }
565
566    /// Gets filtered items for a set of keys
567    pub fn get_item_iter<K: AsRef<[u8]>>(
568        &self,
569        keys: &[K],
570        topive: bool,
571    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
572        self.suber.base.get_item_iter(keys, topive)
573    }
574
575    /// Process raw items into deserialized values
576    pub fn process_items(
577        &self,
578        items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
579    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
580        let mut result = Vec::new();
581
582        for (keys, val) in items {
583            let deserialized = self.base.des(&val)?;
584            result.push((keys, deserialized));
585        }
586
587        Ok(result)
588    }
589    /// Delegate to the suber.base.to_key method
590    pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
591        self.suber.base.to_key(keys, topive)
592    }
593
594    /// Delegate to the suber.base.to_keys method
595    pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
596        self.suber.base.to_keys(key)
597    }
598
599    /// Counts all items in the database
600    pub fn cnt_all(&self) -> Result<usize, SuberError> {
601        self.suber.cnt_all()
602    }
603}
604
605#[cfg(test)]
606mod tests {
607    use crate::cesr::dater::Dater;
608    use crate::cesr::diger::Diger;
609    use crate::cesr::indexing::siger::Siger;
610    use crate::cesr::prefixer::Prefixer;
611    use crate::cesr::saider::Saider;
612    use crate::cesr::seqner::Seqner;
613    use crate::cesr::{BaseMatter, Matter, Parsable};
614    use crate::keri::db::dbing::LMDBerBuilder;
615    use crate::keri::db::subing::catcesr::CatCesrSuber;
616    use crate::keri::db::subing::SuberError;
617
618    use std::sync::Arc;
619
620    #[test]
621    fn test_cat_cesr_suber() -> Result<(), SuberError> {
622        // Open a test database
623        let db = LMDBerBuilder::default()
624            .name("test")
625            .temp(true)
626            .build()
627            .unwrap();
628
629        assert_eq!(db.name(), "test");
630        assert!(db.opened());
631
632        let db_ref = Arc::new(db);
633
634        {
635            // Test Seqner Saider format
636            let db_ref = db_ref.clone();
637            let sdb = CatCesrSuber::<BaseMatter>::new(
638                db_ref.clone(),
639                "ssdb.",
640                vec!["seqner".to_string(), "saider".to_string()],
641                None,
642                false,
643            )?;
644
645            // Create test data
646            let seqner = Seqner::from_sn(42);
647            let seqb = seqner.qb64b();
648            assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAAAq");
649
650            let saider = Saider::from_qb64("EAWY-bDoF3C0LXQBcMNKNnZJNyjRFwzPF6QUQPfBRT7x").unwrap();
651            let saidb = saider.qb64b();
652
653            // Test serialization and deserialization
654            let vals: Vec<&dyn Matter> = vec![&seqner, &saider];
655
656            // Use the CatCesrSuber methods directly through the base
657            let valb = sdb.base.ser(&vals)?;
658            assert_eq!(valb, [&seqb[..], &saidb[..]].concat());
659
660            // Test deserialization
661            let des_result = sdb.base.des(&valb)?;
662            let des_values = des_result;
663
664            // Verify we got 2 Matters back and can be downcast to expected types
665            assert_eq!(des_values.len(), 2);
666
667            let des_seqner = des_values[0].as_any().downcast_ref::<Seqner>().unwrap();
668            let des_saider = des_values[1].as_any().downcast_ref::<Saider>().unwrap();
669
670            assert_eq!(des_seqner.qb64b(), seqner.qb64b());
671            assert_eq!(des_saider.qb64b(), saider.qb64b());
672
673            // Verify concat of all qb64b equals original serialized value
674            let combined = [&des_seqner.qb64b()[..], &des_saider.qb64b()[..]].concat();
675            assert_eq!(combined, valb);
676
677            // Test database operations
678            let keys = ["witness", "receipt"];
679
680            // Test put and get
681            assert!(sdb.put(&keys, &vals)?);
682            let actuals = sdb.get(&keys)?;
683            assert!(actuals.is_some());
684
685            let actuals = actuals.unwrap();
686            assert_eq!(actuals.len(), 2);
687
688            let retrieved_seqner = actuals[0].as_any().downcast_ref::<Seqner>().unwrap();
689            let retrieved_saider = actuals[1].as_any().downcast_ref::<Saider>().unwrap();
690
691            assert_eq!(retrieved_seqner.qb64b(), seqner.qb64b());
692            assert_eq!(retrieved_saider.qb64b(), saider.qb64b());
693
694            // Test removal
695            assert!(sdb.rem(&keys)?);
696            let actuals = sdb.get(&keys)?;
697            assert!(actuals.is_none());
698        }
699
700        {
701            // Test Prefixer Seqner Saider format
702            let db_ref = db_ref.clone();
703            let sdb = CatCesrSuber::<BaseMatter>::new(
704                db_ref.clone(),
705                "pssdb.",
706                vec![
707                    "prefixer".to_string(),
708                    "seqner".to_string(),
709                    "saider".to_string(),
710                ],
711                None,
712                false,
713            )?;
714
715            // Create test data
716            let prefixer =
717                Prefixer::from_qb64("BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc").unwrap();
718            let preb = prefixer.qb64b();
719
720            let seqner = Seqner::from_sn(99);
721            let seqb = seqner.qb64b();
722            assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAABj");
723
724            let saider = Saider::from_qb64("EAWY-bDoF3C0LXQBcMNKNnZJNyjRFwzPF6QUQPfBRT7x").unwrap();
725            let saidb = saider.qb64b();
726
727            // Test serialization and deserialization
728            let vals: Vec<&dyn Matter> = vec![&prefixer, &seqner, &saider];
729
730            // Use the CatCesrSuber methods directly through the base
731            let valb = sdb.base.ser(&vals)?;
732            assert_eq!(valb, [&preb[..], &seqb[..], &saidb[..]].concat());
733
734            // Test deserialization
735            let des_result = sdb.base.des(&valb)?;
736            let des_values = des_result;
737
738            // Verify we got 3 Matters back and can be downcast to expected types
739            assert_eq!(des_values.len(), 3);
740
741            let des_prefixer = des_values[0].as_any().downcast_ref::<Prefixer>().unwrap();
742            let des_seqner = des_values[1].as_any().downcast_ref::<Seqner>().unwrap();
743            let des_saider = des_values[2].as_any().downcast_ref::<Saider>().unwrap();
744
745            assert_eq!(des_prefixer.qb64b(), prefixer.qb64b());
746            assert_eq!(des_seqner.qb64b(), seqner.qb64b());
747            assert_eq!(des_saider.qb64b(), saider.qb64b());
748
749            // Verify concat of all qb64b equals original serialized value
750            let combined = [
751                &des_prefixer.qb64b()[..],
752                &des_seqner.qb64b()[..],
753                &des_saider.qb64b()[..],
754            ]
755            .concat();
756            assert_eq!(combined, valb);
757
758            // Test database operations
759            let keys = ["delegate", "anchor"];
760
761            // Test put and get
762            assert!(sdb.put(&keys, &vals)?);
763            let actuals = sdb.get(&keys)?;
764            assert!(actuals.is_some());
765
766            let actuals = actuals.unwrap();
767            assert_eq!(actuals.len(), 3);
768
769            let retrieved_prefixer = actuals[0].as_any().downcast_ref::<Prefixer>().unwrap();
770            let retrieved_seqner = actuals[1].as_any().downcast_ref::<Seqner>().unwrap();
771            let retrieved_saider = actuals[2].as_any().downcast_ref::<Saider>().unwrap();
772
773            assert_eq!(retrieved_prefixer.qb64b(), prefixer.qb64b());
774            assert_eq!(retrieved_seqner.qb64b(), seqner.qb64b());
775            assert_eq!(retrieved_saider.qb64b(), saider.qb64b());
776
777            // Test pin (overwrite) operation
778            let new_prefixer =
779                Prefixer::from_qb64("BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc").unwrap();
780            let new_seqner = Seqner::from_sn(100);
781            let new_saider =
782                Saider::from_qb64("EBJPik4FxfCl-FFsSyGhHpO1VdRQTqIFr11JrYJBSBVk").unwrap();
783
784            let new_vals: Vec<&dyn Matter> = vec![&new_prefixer, &new_seqner, &new_saider];
785
786            // Pin should overwrite
787            assert!(sdb.pin(&keys, &new_vals)?);
788
789            let actuals = sdb.get(&keys)?.unwrap();
790            assert_eq!(actuals.len(), 3);
791
792            let retrieved_prefixer = actuals[0].as_any().downcast_ref::<Prefixer>().unwrap();
793            let retrieved_seqner = actuals[1].as_any().downcast_ref::<Seqner>().unwrap();
794            let retrieved_saider = actuals[2].as_any().downcast_ref::<Saider>().unwrap();
795
796            assert_eq!(retrieved_prefixer.qb64b(), new_prefixer.qb64b());
797            assert_eq!(retrieved_seqner.qb64b(), new_seqner.qb64b());
798            assert_eq!(retrieved_saider.qb64b(), new_saider.qb64b());
799
800            // Test removal
801            assert!(sdb.rem(&keys)?);
802            let actuals = sdb.get(&keys)?;
803            assert!(actuals.is_none());
804        }
805
806        {
807            // Test Single Matter type
808            let db_ref = db_ref.clone();
809            let sdb = CatCesrSuber::<BaseMatter>::new(
810                db_ref.clone(),
811                "bags.",
812                vec![], // empty formats defaults to BaseMatter
813                Some(b'.'),
814                false,
815            )?;
816
817            // Test data with BaseMatter
818            let matb0 = "BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc";
819            let matter0 = BaseMatter::from_qb64(matb0).unwrap();
820            let vals0: Vec<&dyn Matter> = vec![&matter0];
821
822            let matb1 = "BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
823            let matter1 = BaseMatter::from_qb64(matb1).unwrap();
824            let vals1: Vec<&dyn Matter> = vec![&matter1];
825
826            // Test with tuple keys
827            let keys0 = ["alpha", "dog"];
828
829            // Test put and get
830            assert!(sdb.put(&keys0, &vals0)?);
831            let actuals = sdb.get(&keys0)?;
832            assert!(actuals.is_some());
833
834            let actuals = actuals.unwrap();
835            assert_eq!(actuals.len(), 1);
836
837            // Downcast the retrieved Matter
838            let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
839            assert_eq!(retrieved.qb64(), matter0.qb64());
840
841            // Test remove
842            assert!(sdb.rem(&keys0)?);
843            let actuals = sdb.get(&keys0)?;
844            assert!(actuals.is_none());
845
846            // Put again
847            assert!(sdb.put(&keys0, &vals0)?);
848            let actuals = sdb.get(&keys0)?.unwrap();
849            assert_eq!(actuals.len(), 1);
850            let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
851            assert_eq!(retrieved.qb64(), matter0.qb64());
852
853            // Try regular put with same key (should fail as dupsort is false)
854            let result = sdb.put(&keys0, &vals1)?;
855            assert!(!result);
856
857            // Test pin (which should overwrite)
858            assert!(sdb.pin(&keys0, &vals1)?);
859            let actuals = sdb.get(&keys0)?.unwrap();
860            assert_eq!(actuals.len(), 1);
861            let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
862            assert_eq!(retrieved.qb64(), matter1.qb64());
863
864            // Test removal again
865            assert!(sdb.rem(&keys0)?);
866            let actuals = sdb.get(&keys0)?;
867            assert!(actuals.is_none());
868
869            // Test with string key instead of tuple
870            let keys1 = ["beta.fish"];
871            assert!(sdb.put(&keys1, &vals1)?);
872            let actuals = sdb.get(&keys1)?.unwrap();
873            assert_eq!(actuals.len(), 1);
874            let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
875            assert_eq!(retrieved.qb64(), matter1.qb64());
876
877            // Test removal of string key
878            assert!(sdb.rem(&keys1)?);
879            let actuals = sdb.get(&keys1)?;
880            assert!(actuals.is_none());
881
882            // Test missing entry
883            let badkey = ["badkey"];
884            let actuals = sdb.get(&badkey)?;
885            assert!(actuals.is_none());
886            // Test iteritems
887            assert!(sdb.put(&keys0, &vals0)?);
888            assert!(sdb.put(&keys1, &vals1)?);
889
890            let prefix_key: [&str; 0] = [];
891
892            let raw_items = sdb.get_item_iter(&prefix_key, true)?;
893
894            // Convert raw items to more useful format for verification
895            let items: Vec<(Vec<String>, String)> = raw_items
896                .iter()
897                .map(|(keys, vals)| {
898                    // Convert keys to strings
899                    let key_strs = keys
900                        .iter()
901                        .map(|k| String::from_utf8(k.clone()).unwrap())
902                        .collect();
903
904                    // Get the first Matter and convert to qb64
905                    let matter = BaseMatter::from_qb64b(&mut vals.clone(), None).unwrap();
906                    let qb64 = matter.qb64();
907
908                    (key_strs, qb64)
909                })
910                .collect();
911
912            // Check items match expected
913            // Need to handle "alpha.dog" vs ["alpha", "dog"] based on separator
914            let mut found_item1 = false;
915            let mut found_item2 = false;
916
917            for (key_parts, val) in items {
918                if (key_parts[0] == "alpha" && key_parts[1] == "dog" && val == matter0.qb64())
919                    || (key_parts.len() == 1
920                        && key_parts[0] == "alpha.dog"
921                        && val == matter0.qb64())
922                {
923                    found_item1 = true;
924                }
925                if (key_parts[0] == "beta" && key_parts[1] == "fish" && val == matter1.qb64())
926                    || (key_parts.len() == 1
927                        && key_parts[0] == "beta.fish"
928                        && val == matter1.qb64())
929                {
930                    found_item2 = true;
931                }
932            }
933
934            assert!(found_item1);
935            assert!(found_item2);
936
937            // Test prefix iteration
938            assert!(sdb.put(&["b", "1"], &vals0)?);
939            assert!(sdb.put(&["b", "2"], &vals1)?);
940            assert!(sdb.put(&["c", "1"], &vals0)?);
941            assert!(sdb.put(&["c", "2"], &vals1)?);
942
943            let topkeys = ["b", ""];
944            let raw_items = sdb.get_item_iter(&topkeys, true)?;
945
946            // Convert and check just the b prefix items
947            let items: Vec<(Vec<String>, String)> = raw_items
948                .iter()
949                .map(|(keys, vals)| {
950                    let key_strs = keys
951                        .iter()
952                        .map(|k| String::from_utf8(k.clone()).unwrap())
953                        .collect();
954
955                    let matter = BaseMatter::from_qb64b(&mut vals.clone(), None).unwrap();
956                    let qb64 = matter.qb64();
957
958                    (key_strs, qb64)
959                })
960                .collect();
961
962            // Check we have exactly the two b items
963            assert_eq!(items.len(), 2);
964
965            let mut found_b1 = false;
966            let mut found_b2 = false;
967
968            for (key_parts, val) in items {
969                if (key_parts[0] == "b" && key_parts[1] == "1" && val == matter0.qb64()) {
970                    found_b1 = true;
971                }
972                if (key_parts[0] == "b" && key_parts[1] == "2" && val == matter1.qb64()) {
973                    found_b2 = true;
974                }
975            }
976
977            assert!(found_b1);
978            assert!(found_b2);
979        }
980
981        {
982            // Test multiple klases with Dater, Seqner, Diger format
983            let db_ref = db_ref.clone();
984            let sdb = CatCesrSuber::<BaseMatter>::new(
985                db_ref.clone(),
986                "bags.",
987                vec![
988                    "dater".to_string(),
989                    "seqner".to_string(),
990                    "diger".to_string(),
991                ],
992                None,
993                false,
994            )?;
995
996            // Create test data
997            let dater = Dater::from_dt(chrono::Utc::now());
998            let datb = dater.qb64b();
999
1000            let seqner = Seqner::from_sn(20);
1001            let seqb = seqner.qb64b();
1002            assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAAAU");
1003
1004            let diger = Diger::from_ser("Hello Me Maties.".as_bytes(), None)?;
1005            let digb = diger.qb64b();
1006
1007            // Test serialization and deserialization
1008            let vals: Vec<&dyn Matter> = vec![&dater, &seqner, &diger];
1009
1010            // Use the CatCesrSuber methods directly through the base
1011            let valb = sdb.base.ser(&vals)?;
1012            assert_eq!(valb, [&datb[..], &seqb[..], &digb[..]].concat());
1013
1014            // Test deserialization
1015            let des_result = sdb.base.des(&valb)?;
1016            let des_values = des_result;
1017
1018            // Verify we got 3 Matters back and can be downcast to expected types
1019            assert_eq!(des_values.len(), 3);
1020
1021            let des_dater = des_values[0].as_any().downcast_ref::<Dater>().unwrap();
1022            let des_seqner = des_values[1].as_any().downcast_ref::<Seqner>().unwrap();
1023            let des_diger = des_values[2].as_any().downcast_ref::<Diger>().unwrap();
1024
1025            assert_eq!(des_dater.qb64b(), dater.qb64b());
1026            assert_eq!(des_seqner.qb64b(), seqner.qb64b());
1027            assert_eq!(des_diger.qb64b(), diger.qb64b());
1028
1029            // Verify concat of all qb64b equals original serialized value
1030            let combined = [
1031                &des_dater.qb64b()[..],
1032                &des_seqner.qb64b()[..],
1033                &des_diger.qb64b()[..],
1034            ]
1035            .concat();
1036            assert_eq!(combined, valb);
1037        }
1038
1039        {
1040            // Test Siger format
1041            let db_ref = db_ref.clone();
1042            let sdb = CatCesrSuber::<BaseMatter>::new(
1043                db_ref.clone(),
1044                "pigs.",
1045                vec!["siger".to_string()],
1046                None,
1047                false,
1048            )?;
1049
1050            // Create Siger
1051            let sig0 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
1052            let val0 = Siger::from_qb64(sig0, None).unwrap();
1053
1054            // Test put and get
1055            let keys = ["zeta", "cat"];
1056            assert!(sdb.put(&keys, &[&val0])?);
1057
1058            let actuals = sdb.get(&keys)?.unwrap();
1059            assert_eq!(actuals.len(), 1);
1060
1061            let actual_siger = actuals[0].as_any().downcast_ref::<Siger>().unwrap();
1062            assert_eq!(actual_siger.qb64(), val0.qb64());
1063        }
1064
1065        Ok(())
1066    }
1067}