1use std::sync::Arc;
2
3use openmls_traits::storage::StorageProvider;
4use openmls_traits::storage::{CURRENT_VERSION, traits};
5use parking_lot::Mutex;
6
7use crate::mock::{MockConnection, MockDbQuery};
8use crate::{
9 MemoryStorage,
10 sql_key_store::{SqlKeyStore, SqlKeyStoreError},
11};
12use crate::{MockTransactionalKeyStore, XmtpMlsStorageProvider};
13
14#[derive(Clone)]
18pub struct MockSqlKeyStore {
19 in_memory: Arc<SqlKeyStore<MemoryStorage>>,
20 db_query: Arc<MockDbQuery>,
21 pub mock_mls: Arc<Mutex<MockTransactionalKeyStore>>,
22}
23
24impl MockSqlKeyStore {
25 pub fn mls(&self) -> &impl XmtpMlsStorageProvider {
26 self.in_memory.as_ref()
27 }
28}
29
30impl MockSqlKeyStore {
31 pub fn new(
32 db: Arc<MockDbQuery>,
33 store: MockTransactionalKeyStore,
34 mem: Arc<SqlKeyStore<MemoryStorage>>,
35 ) -> Self {
36 Self {
37 db_query: db,
38 in_memory: mem,
39 mock_mls: Arc::new(Mutex::new(store)),
40 }
41 }
42}
43
44impl XmtpMlsStorageProvider for MockSqlKeyStore {
45 type Connection = MockConnection;
46
47 type DbQuery<'a> = &'a MockDbQuery;
48
49 type TxQuery = MockTransactionalKeyStore;
50
51 fn db<'a>(&'a self) -> Self::DbQuery<'a> {
52 self.db_query.as_ref()
53 }
54
55 #[tracing::instrument(level = "trace", skip_all)]
56 fn transaction<T, E, F>(&self, f: F) -> Result<T, E>
57 where
58 F: FnOnce(&mut Self::TxQuery) -> Result<T, E>,
59 E: From<diesel::result::Error> + From<crate::ConnectionError> + std::error::Error,
60 {
61 let mut store = self.mock_mls.lock();
62 f(&mut store)
63 }
64
65 fn savepoint<T, E, F>(&self, f: F) -> Result<T, E>
66 where
67 F: FnOnce(&mut Self::TxQuery) -> Result<T, E>,
68 E: From<diesel::result::Error> + From<crate::ConnectionError> + std::error::Error,
69 {
70 let mut store = self.mock_mls.lock();
71 f(&mut store)
72 }
73
74 #[tracing::instrument(level = "trace", skip(self))]
75 fn read<V: openmls_traits::storage::Entity<CURRENT_VERSION>>(
76 &self,
77 label: &[u8],
78 key: &[u8],
79 ) -> Result<Option<V>, SqlKeyStoreError> {
80 XmtpMlsStorageProvider::read::<V>(self.in_memory.as_ref(), label, key)
81 }
82
83 #[tracing::instrument(level = "trace", skip_all)]
84 fn read_list<V: openmls_traits::storage::Entity<CURRENT_VERSION>>(
85 &self,
86 label: &[u8],
87 key: &[u8],
88 ) -> Result<Vec<V>, <Self as StorageProvider<CURRENT_VERSION>>::Error> {
89 XmtpMlsStorageProvider::read_list::<V>(self.in_memory.as_ref(), label, key)
90 }
91
92 #[tracing::instrument(level = "trace", skip(self))]
93 fn delete(
94 &self,
95 label: &[u8],
96 key: &[u8],
97 ) -> Result<(), <Self as StorageProvider<CURRENT_VERSION>>::Error> {
98 self.in_memory.delete::<CURRENT_VERSION>(label, key)
99 }
100
101 #[tracing::instrument(level = "trace", skip(self))]
102 fn write(
103 &self,
104 label: &[u8],
105 key: &[u8],
106 value: &[u8],
107 ) -> Result<(), <Self as StorageProvider<CURRENT_VERSION>>::Error> {
108 self.in_memory.write::<CURRENT_VERSION>(label, key, value)
109 }
110
111 #[cfg(feature = "test-utils")]
112 fn hash_all(&self) -> Result<Vec<u8>, SqlKeyStoreError> {
113 self.in_memory.hash_all()
114 }
115}
116
117impl StorageProvider<CURRENT_VERSION> for MockSqlKeyStore {
118 type Error = SqlKeyStoreError;
119
120 #[tracing::instrument(level = "trace", skip_all)]
121 fn queue_proposal<
122 GroupId: traits::GroupId<CURRENT_VERSION>,
123 ProposalRef: traits::ProposalRef<CURRENT_VERSION>,
124 QueuedProposal: traits::QueuedProposal<CURRENT_VERSION>,
125 >(
126 &self,
127 group_id: &GroupId,
128 proposal_ref: &ProposalRef,
129 proposal: &QueuedProposal,
130 ) -> Result<(), Self::Error> {
131 self.in_memory
132 .queue_proposal::<GroupId, ProposalRef, QueuedProposal>(
133 group_id,
134 proposal_ref,
135 proposal,
136 )
137 }
138
139 #[tracing::instrument(level = "trace", skip_all)]
140 fn write_tree<
141 GroupId: traits::GroupId<CURRENT_VERSION>,
142 TreeSync: traits::TreeSync<CURRENT_VERSION>,
143 >(
144 &self,
145 group_id: &GroupId,
146 tree: &TreeSync,
147 ) -> Result<(), Self::Error> {
148 self.in_memory
149 .write_tree::<GroupId, TreeSync>(group_id, tree)
150 }
151
152 #[tracing::instrument(level = "trace", skip_all)]
153 fn write_interim_transcript_hash<
154 GroupId: traits::GroupId<CURRENT_VERSION>,
155 InterimTranscriptHash: traits::InterimTranscriptHash<CURRENT_VERSION>,
156 >(
157 &self,
158 group_id: &GroupId,
159 interim_transcript_hash: &InterimTranscriptHash,
160 ) -> Result<(), Self::Error> {
161 self.in_memory
162 .write_interim_transcript_hash::<GroupId, InterimTranscriptHash>(
163 group_id,
164 interim_transcript_hash,
165 )
166 }
167
168 #[tracing::instrument(level = "trace", skip_all)]
169 fn write_context<
170 GroupId: traits::GroupId<CURRENT_VERSION>,
171 GroupContext: traits::GroupContext<CURRENT_VERSION>,
172 >(
173 &self,
174 group_id: &GroupId,
175 group_context: &GroupContext,
176 ) -> Result<(), Self::Error> {
177 self.in_memory
178 .write_context::<GroupId, GroupContext>(group_id, group_context)
179 }
180
181 #[tracing::instrument(level = "trace", skip_all)]
182 fn write_confirmation_tag<
183 GroupId: traits::GroupId<CURRENT_VERSION>,
184 ConfirmationTag: traits::ConfirmationTag<CURRENT_VERSION>,
185 >(
186 &self,
187 group_id: &GroupId,
188 confirmation_tag: &ConfirmationTag,
189 ) -> Result<(), Self::Error> {
190 self.in_memory
191 .write_confirmation_tag::<GroupId, ConfirmationTag>(group_id, confirmation_tag)
192 }
193
194 #[tracing::instrument(level = "trace", skip_all)]
195 fn write_signature_key_pair<
196 SignaturePublicKey: traits::SignaturePublicKey<CURRENT_VERSION>,
197 SignatureKeyPair: traits::SignatureKeyPair<CURRENT_VERSION>,
198 >(
199 &self,
200 public_key: &SignaturePublicKey,
201 signature_key_pair: &SignatureKeyPair,
202 ) -> Result<(), Self::Error> {
203 self.in_memory
204 .write_signature_key_pair::<SignaturePublicKey, SignatureKeyPair>(
205 public_key,
206 signature_key_pair,
207 )
208 }
209
210 #[tracing::instrument(level = "trace", skip_all)]
211 fn queued_proposal_refs<
212 GroupId: traits::GroupId<CURRENT_VERSION>,
213 ProposalRef: traits::ProposalRef<CURRENT_VERSION>,
214 >(
215 &self,
216 group_id: &GroupId,
217 ) -> Result<Vec<ProposalRef>, Self::Error> {
218 self.in_memory
219 .queued_proposal_refs::<GroupId, ProposalRef>(group_id)
220 }
221
222 #[tracing::instrument(level = "trace", skip_all)]
223 fn queued_proposals<
224 GroupId: traits::GroupId<CURRENT_VERSION>,
225 ProposalRef: traits::ProposalRef<CURRENT_VERSION>,
226 QueuedProposal: traits::QueuedProposal<CURRENT_VERSION>,
227 >(
228 &self,
229 group_id: &GroupId,
230 ) -> Result<Vec<(ProposalRef, QueuedProposal)>, Self::Error> {
231 self.in_memory
232 .queued_proposals::<GroupId, ProposalRef, QueuedProposal>(group_id)
233 }
234
235 #[tracing::instrument(level = "trace", skip_all)]
236 fn tree<
237 GroupId: traits::GroupId<CURRENT_VERSION>,
238 TreeSync: traits::TreeSync<CURRENT_VERSION>,
239 >(
240 &self,
241 group_id: &GroupId,
242 ) -> Result<Option<TreeSync>, Self::Error> {
243 self.in_memory.tree::<GroupId, TreeSync>(group_id)
244 }
245
246 #[tracing::instrument(level = "trace", skip_all)]
247 fn group_context<
248 GroupId: traits::GroupId<CURRENT_VERSION>,
249 GroupContext: traits::GroupContext<CURRENT_VERSION>,
250 >(
251 &self,
252 group_id: &GroupId,
253 ) -> Result<Option<GroupContext>, Self::Error> {
254 self.in_memory
255 .group_context::<GroupId, GroupContext>(group_id)
256 }
257
258 #[tracing::instrument(level = "trace", skip_all)]
259 fn interim_transcript_hash<
260 GroupId: traits::GroupId<CURRENT_VERSION>,
261 InterimTranscriptHash: traits::InterimTranscriptHash<CURRENT_VERSION>,
262 >(
263 &self,
264 group_id: &GroupId,
265 ) -> Result<Option<InterimTranscriptHash>, Self::Error> {
266 self.in_memory
267 .interim_transcript_hash::<GroupId, InterimTranscriptHash>(group_id)
268 }
269
270 #[tracing::instrument(level = "trace", skip_all)]
271 fn confirmation_tag<
272 GroupId: traits::GroupId<CURRENT_VERSION>,
273 ConfirmationTag: traits::ConfirmationTag<CURRENT_VERSION>,
274 >(
275 &self,
276 group_id: &GroupId,
277 ) -> Result<Option<ConfirmationTag>, Self::Error> {
278 self.in_memory
279 .confirmation_tag::<GroupId, ConfirmationTag>(group_id)
280 }
281
282 #[tracing::instrument(level = "trace", skip_all)]
283 fn signature_key_pair<
284 SignaturePublicKey: traits::SignaturePublicKey<CURRENT_VERSION>,
285 SignatureKeyPair: traits::SignatureKeyPair<CURRENT_VERSION>,
286 >(
287 &self,
288 public_key: &SignaturePublicKey,
289 ) -> Result<Option<SignatureKeyPair>, Self::Error> {
290 self.in_memory
291 .signature_key_pair::<SignaturePublicKey, SignatureKeyPair>(public_key)
292 }
293
294 #[tracing::instrument(level = "trace", skip_all)]
295 fn write_key_package<
296 HashReference: traits::HashReference<CURRENT_VERSION>,
297 KeyPackage: traits::KeyPackage<CURRENT_VERSION>,
298 >(
299 &self,
300 hash_ref: &HashReference,
301 key_package: &KeyPackage,
302 ) -> Result<(), Self::Error> {
303 self.in_memory
304 .write_key_package::<HashReference, KeyPackage>(hash_ref, key_package)
305 }
306
307 #[tracing::instrument(level = "trace", skip_all)]
308 fn write_psk<
309 PskId: traits::PskId<CURRENT_VERSION>,
310 PskBundle: traits::PskBundle<CURRENT_VERSION>,
311 >(
312 &self,
313 _psk_id: &PskId,
314 _psk: &PskBundle,
315 ) -> Result<(), Self::Error> {
316 self.in_memory.write_psk::<PskId, PskBundle>(_psk_id, _psk)
317 }
318
319 #[tracing::instrument(level = "trace", skip_all)]
320 fn write_encryption_key_pair<
321 EncryptionKey: traits::EncryptionKey<CURRENT_VERSION>,
322 HpkeKeyPair: traits::HpkeKeyPair<CURRENT_VERSION>,
323 >(
324 &self,
325 public_key: &EncryptionKey,
326 key_pair: &HpkeKeyPair,
327 ) -> Result<(), Self::Error> {
328 self.in_memory
329 .write_encryption_key_pair::<EncryptionKey, HpkeKeyPair>(public_key, key_pair)
330 }
331
332 #[tracing::instrument(level = "trace", skip_all)]
333 fn key_package<
334 HashReference: traits::HashReference<CURRENT_VERSION>,
335 KeyPackage: traits::KeyPackage<CURRENT_VERSION>,
336 >(
337 &self,
338 hash_ref: &HashReference,
339 ) -> Result<Option<KeyPackage>, Self::Error> {
340 self.in_memory
341 .key_package::<HashReference, KeyPackage>(hash_ref)
342 }
343
344 #[tracing::instrument(level = "trace", skip_all)]
345 fn psk<PskBundle: traits::PskBundle<CURRENT_VERSION>, PskId: traits::PskId<CURRENT_VERSION>>(
346 &self,
347 _psk_id: &PskId,
348 ) -> Result<Option<PskBundle>, Self::Error> {
349 self.in_memory.psk::<PskBundle, PskId>(_psk_id)
350 }
351
352 #[tracing::instrument(level = "trace", skip_all)]
353 fn encryption_key_pair<
354 HpkeKeyPair: traits::HpkeKeyPair<CURRENT_VERSION>,
355 EncryptionKey: traits::EncryptionKey<CURRENT_VERSION>,
356 >(
357 &self,
358 public_key: &EncryptionKey,
359 ) -> Result<Option<HpkeKeyPair>, Self::Error> {
360 self.in_memory
361 .encryption_key_pair::<HpkeKeyPair, EncryptionKey>(public_key)
362 }
363
364 #[tracing::instrument(level = "trace", skip_all)]
365 fn delete_signature_key_pair<
366 SignaturePublicKey: traits::SignaturePublicKey<CURRENT_VERSION>,
367 >(
368 &self,
369 public_key: &SignaturePublicKey,
370 ) -> Result<(), Self::Error> {
371 self.in_memory
372 .delete_signature_key_pair::<SignaturePublicKey>(public_key)
373 }
374
375 #[tracing::instrument(level = "trace", skip_all)]
376 fn delete_encryption_key_pair<EncryptionKey: traits::EncryptionKey<CURRENT_VERSION>>(
377 &self,
378 public_key: &EncryptionKey,
379 ) -> Result<(), Self::Error> {
380 self.in_memory
381 .delete_encryption_key_pair::<EncryptionKey>(public_key)
382 }
383
384 #[tracing::instrument(level = "trace", skip_all)]
385 fn delete_key_package<HashReference: traits::HashReference<CURRENT_VERSION>>(
386 &self,
387 hash_ref: &HashReference,
388 ) -> Result<(), Self::Error> {
389 self.in_memory.delete_key_package::<HashReference>(hash_ref)
390 }
391
392 #[tracing::instrument(level = "trace", skip_all)]
393 fn delete_psk<PskKey: traits::PskId<CURRENT_VERSION>>(
394 &self,
395 _psk_id: &PskKey,
396 ) -> Result<(), Self::Error> {
397 Err(SqlKeyStoreError::UnsupportedMethod)
398 }
399
400 #[tracing::instrument(level = "trace", skip_all)]
401 fn group_state<
402 GroupState: traits::GroupState<CURRENT_VERSION>,
403 GroupId: traits::GroupId<CURRENT_VERSION>,
404 >(
405 &self,
406 group_id: &GroupId,
407 ) -> Result<Option<GroupState>, Self::Error> {
408 self.in_memory.group_state::<GroupState, GroupId>(group_id)
409 }
410
411 #[tracing::instrument(level = "trace", skip_all)]
412 fn write_group_state<
413 GroupState: traits::GroupState<CURRENT_VERSION>,
414 GroupId: traits::GroupId<CURRENT_VERSION>,
415 >(
416 &self,
417 group_id: &GroupId,
418 group_state: &GroupState,
419 ) -> Result<(), Self::Error> {
420 self.in_memory
421 .write_group_state::<GroupState, GroupId>(group_id, group_state)
422 }
423
424 #[tracing::instrument(level = "trace", skip_all)]
425 fn delete_group_state<GroupId: traits::GroupId<CURRENT_VERSION>>(
426 &self,
427 group_id: &GroupId,
428 ) -> Result<(), Self::Error> {
429 self.in_memory.delete_group_state::<GroupId>(group_id)
430 }
431
432 #[tracing::instrument(level = "trace", skip_all)]
433 fn message_secrets<
434 GroupId: traits::GroupId<CURRENT_VERSION>,
435 MessageSecrets: traits::MessageSecrets<CURRENT_VERSION>,
436 >(
437 &self,
438 group_id: &GroupId,
439 ) -> Result<Option<MessageSecrets>, Self::Error> {
440 self.in_memory
441 .message_secrets::<GroupId, MessageSecrets>(group_id)
442 }
443
444 #[tracing::instrument(level = "trace", skip_all)]
445 fn write_message_secrets<
446 GroupId: traits::GroupId<CURRENT_VERSION>,
447 MessageSecrets: traits::MessageSecrets<CURRENT_VERSION>,
448 >(
449 &self,
450 group_id: &GroupId,
451 message_secrets: &MessageSecrets,
452 ) -> Result<(), Self::Error> {
453 self.in_memory
454 .write_message_secrets::<GroupId, MessageSecrets>(group_id, message_secrets)
455 }
456
457 #[tracing::instrument(level = "trace", skip_all)]
458 fn delete_message_secrets<GroupId: traits::GroupId<CURRENT_VERSION>>(
459 &self,
460 group_id: &GroupId,
461 ) -> Result<(), Self::Error> {
462 self.in_memory.delete_message_secrets::<GroupId>(group_id)
463 }
464
465 #[tracing::instrument(level = "trace", skip_all)]
466 fn resumption_psk_store<
467 GroupId: traits::GroupId<CURRENT_VERSION>,
468 ResumptionPskStore: traits::ResumptionPskStore<CURRENT_VERSION>,
469 >(
470 &self,
471 group_id: &GroupId,
472 ) -> Result<Option<ResumptionPskStore>, Self::Error> {
473 self.in_memory.resumption_psk_store(group_id)
474 }
475
476 #[tracing::instrument(level = "trace", skip_all)]
477 fn write_resumption_psk_store<
478 GroupId: traits::GroupId<CURRENT_VERSION>,
479 ResumptionPskStore: traits::ResumptionPskStore<CURRENT_VERSION>,
480 >(
481 &self,
482 group_id: &GroupId,
483 resumption_psk_store: &ResumptionPskStore,
484 ) -> Result<(), Self::Error> {
485 self.in_memory
486 .write_resumption_psk_store::<GroupId, ResumptionPskStore>(
487 group_id,
488 resumption_psk_store,
489 )
490 }
491
492 #[tracing::instrument(level = "trace", skip_all)]
493 fn delete_all_resumption_psk_secrets<GroupId: traits::GroupId<CURRENT_VERSION>>(
494 &self,
495 group_id: &GroupId,
496 ) -> Result<(), Self::Error> {
497 self.in_memory.delete_all_resumption_psk_secrets(group_id)
498 }
499
500 #[tracing::instrument(level = "trace", skip_all)]
501 fn own_leaf_index<
502 GroupId: traits::GroupId<CURRENT_VERSION>,
503 LeafNodeIndex: traits::LeafNodeIndex<CURRENT_VERSION>,
504 >(
505 &self,
506 group_id: &GroupId,
507 ) -> Result<Option<LeafNodeIndex>, Self::Error> {
508 self.in_memory.own_leaf_index(group_id)
509 }
510
511 #[tracing::instrument(level = "trace", skip_all)]
512 fn write_own_leaf_index<
513 GroupId: traits::GroupId<CURRENT_VERSION>,
514 LeafNodeIndex: traits::LeafNodeIndex<CURRENT_VERSION>,
515 >(
516 &self,
517 group_id: &GroupId,
518 own_leaf_index: &LeafNodeIndex,
519 ) -> Result<(), Self::Error> {
520 self.in_memory
521 .write_own_leaf_index::<GroupId, LeafNodeIndex>(group_id, own_leaf_index)
522 }
523
524 #[tracing::instrument(level = "trace", skip_all)]
525 fn delete_own_leaf_index<GroupId: traits::GroupId<CURRENT_VERSION>>(
526 &self,
527 group_id: &GroupId,
528 ) -> Result<(), Self::Error> {
529 self.in_memory.delete_own_leaf_index::<GroupId>(group_id)
530 }
531
532 #[tracing::instrument(level = "trace", skip_all)]
533 fn group_epoch_secrets<
534 GroupId: traits::GroupId<CURRENT_VERSION>,
535 GroupEpochSecrets: traits::GroupEpochSecrets<CURRENT_VERSION>,
536 >(
537 &self,
538 group_id: &GroupId,
539 ) -> Result<Option<GroupEpochSecrets>, Self::Error> {
540 self.in_memory.group_epoch_secrets(group_id)
541 }
542
543 #[tracing::instrument(level = "trace", skip_all)]
544 fn write_group_epoch_secrets<
545 GroupId: traits::GroupId<CURRENT_VERSION>,
546 GroupEpochSecrets: traits::GroupEpochSecrets<CURRENT_VERSION>,
547 >(
548 &self,
549 group_id: &GroupId,
550 group_epoch_secrets: &GroupEpochSecrets,
551 ) -> Result<(), Self::Error> {
552 self.in_memory
553 .write_group_epoch_secrets::<GroupId, GroupEpochSecrets>(group_id, group_epoch_secrets)
554 }
555
556 #[tracing::instrument(level = "trace", skip_all)]
557 fn delete_group_epoch_secrets<GroupId: traits::GroupId<CURRENT_VERSION>>(
558 &self,
559 group_id: &GroupId,
560 ) -> Result<(), Self::Error> {
561 self.in_memory
562 .delete_group_epoch_secrets::<GroupId>(group_id)
563 }
564
565 #[tracing::instrument(level = "trace", skip_all)]
566 fn write_encryption_epoch_key_pairs<
567 GroupId: traits::GroupId<CURRENT_VERSION>,
568 EpochKey: traits::EpochKey<CURRENT_VERSION>,
569 HpkeKeyPair: traits::HpkeKeyPair<CURRENT_VERSION>,
570 >(
571 &self,
572 group_id: &GroupId,
573 epoch: &EpochKey,
574 leaf_index: u32,
575 key_pairs: &[HpkeKeyPair],
576 ) -> Result<(), Self::Error> {
577 self.in_memory
578 .write_encryption_epoch_key_pairs(group_id, epoch, leaf_index, key_pairs)
579 }
580
581 #[tracing::instrument(level = "trace", skip_all)]
582 fn encryption_epoch_key_pairs<
583 GroupId: traits::GroupId<CURRENT_VERSION>,
584 EpochKey: traits::EpochKey<CURRENT_VERSION>,
585 HpkeKeyPair: traits::HpkeKeyPair<CURRENT_VERSION>,
586 >(
587 &self,
588 group_id: &GroupId,
589 epoch: &EpochKey,
590 leaf_index: u32,
591 ) -> Result<Vec<HpkeKeyPair>, Self::Error> {
592 self.in_memory
593 .encryption_epoch_key_pairs(group_id, epoch, leaf_index)
594 }
595
596 #[tracing::instrument(level = "trace", skip_all)]
597 fn delete_encryption_epoch_key_pairs<
598 GroupId: traits::GroupId<CURRENT_VERSION>,
599 EpochKey: traits::EpochKey<CURRENT_VERSION>,
600 >(
601 &self,
602 group_id: &GroupId,
603 epoch: &EpochKey,
604 leaf_index: u32,
605 ) -> Result<(), Self::Error> {
606 self.in_memory
607 .delete_encryption_epoch_key_pairs(group_id, epoch, leaf_index)
608 }
609
610 #[tracing::instrument(level = "trace", skip_all)]
611 fn clear_proposal_queue<
612 GroupId: traits::GroupId<CURRENT_VERSION>,
613 ProposalRef: traits::ProposalRef<CURRENT_VERSION>,
614 >(
615 &self,
616 group_id: &GroupId,
617 ) -> Result<(), Self::Error> {
618 self.in_memory
619 .clear_proposal_queue::<GroupId, ProposalRef>(group_id)
620 }
621
622 #[tracing::instrument(level = "trace", skip_all)]
623 fn mls_group_join_config<
624 GroupId: traits::GroupId<CURRENT_VERSION>,
625 MlsGroupJoinConfig: traits::MlsGroupJoinConfig<CURRENT_VERSION>,
626 >(
627 &self,
628 group_id: &GroupId,
629 ) -> Result<Option<MlsGroupJoinConfig>, Self::Error> {
630 self.in_memory
631 .mls_group_join_config::<GroupId, MlsGroupJoinConfig>(group_id)
632 }
633
634 #[tracing::instrument(level = "trace", skip_all)]
635 fn write_mls_join_config<
636 GroupId: traits::GroupId<CURRENT_VERSION>,
637 MlsGroupJoinConfig: traits::MlsGroupJoinConfig<CURRENT_VERSION>,
638 >(
639 &self,
640 group_id: &GroupId,
641 config: &MlsGroupJoinConfig,
642 ) -> Result<(), Self::Error> {
643 self.in_memory
644 .write_mls_join_config::<GroupId, MlsGroupJoinConfig>(group_id, config)
645 }
646
647 #[tracing::instrument(level = "trace", skip_all)]
648 fn own_leaf_nodes<
649 GroupId: traits::GroupId<CURRENT_VERSION>,
650 LeafNode: traits::LeafNode<CURRENT_VERSION>,
651 >(
652 &self,
653 group_id: &GroupId,
654 ) -> Result<Vec<LeafNode>, Self::Error> {
655 self.in_memory.own_leaf_nodes::<GroupId, LeafNode>(group_id)
656 }
657
658 #[tracing::instrument(level = "trace", skip_all)]
659 fn append_own_leaf_node<
660 GroupId: traits::GroupId<CURRENT_VERSION>,
661 LeafNode: traits::LeafNode<CURRENT_VERSION>,
662 >(
663 &self,
664 group_id: &GroupId,
665 leaf_node: &LeafNode,
666 ) -> Result<(), Self::Error> {
667 self.in_memory.append_own_leaf_node(group_id, leaf_node)
668 }
669
670 #[tracing::instrument(level = "trace", skip_all)]
671 fn delete_own_leaf_nodes<GroupId: traits::GroupId<CURRENT_VERSION>>(
672 &self,
673 group_id: &GroupId,
674 ) -> Result<(), Self::Error> {
675 self.in_memory.delete_own_leaf_nodes(group_id)
676 }
677
678 #[tracing::instrument(level = "trace", skip_all)]
679 fn delete_group_config<GroupId: traits::GroupId<CURRENT_VERSION>>(
680 &self,
681 group_id: &GroupId,
682 ) -> Result<(), Self::Error> {
683 self.in_memory.delete_group_config::<GroupId>(group_id)
684 }
685
686 #[tracing::instrument(level = "trace", skip_all)]
687 fn delete_tree<GroupId: traits::GroupId<CURRENT_VERSION>>(
688 &self,
689 group_id: &GroupId,
690 ) -> Result<(), Self::Error> {
691 self.in_memory.delete_tree(group_id)
692 }
693
694 #[tracing::instrument(level = "trace", skip_all)]
695 fn delete_confirmation_tag<GroupId: traits::GroupId<CURRENT_VERSION>>(
696 &self,
697 group_id: &GroupId,
698 ) -> Result<(), Self::Error> {
699 self.in_memory.delete_confirmation_tag::<GroupId>(group_id)
700 }
701
702 #[tracing::instrument(level = "trace", skip_all)]
703 fn delete_context<GroupId: traits::GroupId<CURRENT_VERSION>>(
704 &self,
705 group_id: &GroupId,
706 ) -> Result<(), Self::Error> {
707 self.in_memory.delete_context::<GroupId>(group_id)
708 }
709
710 #[tracing::instrument(level = "trace", skip_all)]
711 fn delete_interim_transcript_hash<GroupId: traits::GroupId<CURRENT_VERSION>>(
712 &self,
713 group_id: &GroupId,
714 ) -> Result<(), Self::Error> {
715 self.in_memory
716 .delete_interim_transcript_hash::<GroupId>(group_id)
717 }
718
719 #[tracing::instrument(level = "trace", skip_all)]
720 fn remove_proposal<
721 GroupId: traits::GroupId<CURRENT_VERSION>,
722 ProposalRef: traits::ProposalRef<CURRENT_VERSION>,
723 >(
724 &self,
725 group_id: &GroupId,
726 proposal_ref: &ProposalRef,
727 ) -> Result<(), Self::Error> {
728 self.in_memory
729 .remove_proposal::<GroupId, ProposalRef>(group_id, proposal_ref)
730 }
731}