1use thiserror::Error;
9
10use crate::{
11 error::LibraryError,
12 extensions::errors::InvalidExtensionError,
13 group::{
14 errors::{
15 CreateAddProposalError, CreateCommitError, MergeCommitError, StageCommitError,
16 ValidationError,
17 },
18 CommitBuilderStageError, CreateGroupContextExtProposalError,
19 },
20 schedule::errors::PskError,
21 treesync::{
22 errors::{LeafNodeValidationError, PublicTreeError},
23 node::leaf_node::LeafNodeUpdateError,
24 },
25};
26
27#[derive(Error, Debug, PartialEq, Clone)]
29pub enum NewGroupError<StorageError> {
30 #[error(transparent)]
32 LibraryError(#[from] LibraryError),
33 #[error("No matching KeyPackage was found in the key store.")]
35 NoMatchingKeyPackage,
36 #[error("Error accessing the storage.")]
38 StorageError(StorageError),
39 #[error("Unsupported proposal type in required capabilities.")]
41 UnsupportedProposalType,
42 #[error("Unsupported extension type in required capabilities.")]
44 UnsupportedExtensionType,
45 #[error("Invalid extensions set in configuration")]
47 InvalidExtensions(#[from] InvalidExtensionError),
48}
49
50#[derive(Error, Debug, PartialEq, Eq, Clone)]
52pub enum EmptyInputError {
53 #[error("An empty list of KeyPackages was provided.")]
55 AddMembers,
56 #[error("An empty list of KeyPackage references was provided.")]
58 RemoveMembers,
59}
60
61#[derive(Error, Debug, PartialEq, Clone)]
63pub enum MlsGroupStateError {
64 #[error(transparent)]
66 LibraryError(#[from] LibraryError),
67 #[error("Tried to use a group after being evicted from it.")]
69 UseAfterEviction,
70 #[error("Can't create message because a pending proposal exists.")]
72 PendingProposal,
73 #[error("Can't execute operation because a pending commit exists.")]
75 PendingCommit,
76 #[error("Can't execute operation because there is no pending commit")]
78 NoPendingCommit,
79 #[error("Requested pending proposal hasn't been found in local pending proposals.")]
81 PendingProposalNotFound,
82}
83
84#[derive(Error, Debug, PartialEq, Clone)]
86pub enum MergePendingCommitError<StorageError> {
87 #[error(transparent)]
89 MlsGroupStateError(#[from] MlsGroupStateError),
90 #[error(transparent)]
92 MergeCommitError(#[from] MergeCommitError<StorageError>),
93}
94
95#[derive(Error, Debug, PartialEq, Clone)]
97pub enum ProcessMessageError {
98 #[error(transparent)]
100 LibraryError(#[from] LibraryError),
101 #[error("The message's wire format is incompatible with the group's wire format policy.")]
103 IncompatibleWireFormat,
104 #[error(transparent)]
106 ValidationError(#[from] ValidationError),
107 #[error(transparent)]
109 GroupStateError(#[from] MlsGroupStateError),
110 #[error(transparent)]
112 InvalidCommit(#[from] StageCommitError),
113 #[error("External application messages are not permitted.")]
115 UnauthorizedExternalApplicationMessage,
116 #[error("Commit messages from external senders are not permitted.")]
118 UnauthorizedExternalCommitMessage,
119 #[error("The proposal is invalid for the Sender of type External")]
121 UnsupportedProposalType,
122}
123
124#[derive(Error, Debug, PartialEq, Clone)]
126pub enum CreateMessageError {
127 #[error(transparent)]
129 LibraryError(#[from] LibraryError),
130 #[error(transparent)]
132 GroupStateError(#[from] MlsGroupStateError),
133}
134
135#[derive(Error, Debug, PartialEq, Clone)]
137pub enum AddMembersError<StorageError> {
138 #[error(transparent)]
140 LibraryError(#[from] LibraryError),
141 #[error(transparent)]
143 EmptyInput(#[from] EmptyInputError),
144 #[error(transparent)]
146 CreateCommitError(#[from] CreateCommitError),
147 #[error(transparent)]
149 CommitBuilderStageError(#[from] CommitBuilderStageError<StorageError>),
150 #[error(transparent)]
152 GroupStateError(#[from] MlsGroupStateError),
153 #[error("Error writing to storage")]
155 StorageError(StorageError),
156}
157
158#[derive(Error, Debug, PartialEq, Clone)]
160pub enum ProposeAddMemberError<StorageError> {
161 #[error(transparent)]
163 LibraryError(#[from] LibraryError),
164 #[error("The new member does not support all required extensions.")]
166 UnsupportedExtensions,
167 #[error(transparent)]
169 GroupStateError(#[from] MlsGroupStateError),
170 #[error(transparent)]
172 LeafNodeValidation(#[from] LeafNodeValidationError),
173 #[error("Error writing to storage: {0}")]
175 StorageError(StorageError),
176}
177
178#[derive(Error, Debug, PartialEq, Clone)]
180pub enum ProposeRemoveMemberError<StorageError> {
181 #[error(transparent)]
183 LibraryError(#[from] LibraryError),
184 #[error(transparent)]
186 GroupStateError(#[from] MlsGroupStateError),
187 #[error("The member that should be removed can not be found.")]
189 UnknownMember,
190 #[error("Error writing to storage: {0}")]
192 StorageError(StorageError),
193}
194
195#[derive(Error, Debug, PartialEq, Clone)]
197pub enum RemoveMembersError<StorageError> {
198 #[error(transparent)]
200 LibraryError(#[from] LibraryError),
201 #[error(transparent)]
203 EmptyInput(#[from] EmptyInputError),
204 #[error(transparent)]
206 CreateCommitError(#[from] CreateCommitError),
207 #[error(transparent)]
209 CommitBuilderStageError(#[from] CommitBuilderStageError<StorageError>),
210 #[error(transparent)]
212 GroupStateError(#[from] MlsGroupStateError),
213 #[error("The member that should be removed can not be found.")]
215 UnknownMember,
216 #[error("Error writing to storage: {0}")]
218 StorageError(StorageError),
219}
220
221#[derive(Error, Debug, PartialEq, Clone)]
223pub enum LeaveGroupError<StorageError> {
224 #[error(transparent)]
226 LibraryError(#[from] LibraryError),
227 #[error(transparent)]
229 GroupStateError(#[from] MlsGroupStateError),
230 #[error("An error ocurred while writing to storage")]
232 StorageError(StorageError),
233 #[error("SelfRemove not allowed with pure ciphertext outgoing wire format policy.")]
235 CannotSelfRemoveWithPureCiphertext,
236}
237
238#[derive(Error, Debug, PartialEq, Clone)]
240pub enum SelfUpdateError<StorageError> {
241 #[error(transparent)]
243 LibraryError(#[from] LibraryError),
244 #[error(transparent)]
246 CreateCommitError(#[from] CreateCommitError),
247 #[error(transparent)]
249 CommitBuilderStageError(#[from] CommitBuilderStageError<StorageError>),
250 #[error(transparent)]
252 GroupStateError(#[from] MlsGroupStateError),
253 #[error("Error accessing the storage.")]
255 StorageError(StorageError),
256}
257
258#[derive(Error, Debug, PartialEq, Clone)]
260pub enum ProposeSelfUpdateError<StorageError> {
261 #[error(transparent)]
263 LibraryError(#[from] LibraryError),
264
265 #[error(transparent)]
267 GroupStateError(#[from] MlsGroupStateError),
268 #[error("Error accessing storage.")]
270 StorageError(StorageError),
271 #[error(transparent)]
273 PublicTreeError(#[from] PublicTreeError),
274 #[error(transparent)]
276 LeafNodeUpdateError(#[from] LeafNodeUpdateError<StorageError>),
277}
278
279#[derive(Error, Debug, PartialEq, Clone)]
281pub enum CommitToPendingProposalsError<StorageError> {
282 #[error(transparent)]
284 LibraryError(#[from] LibraryError),
285 #[error(transparent)]
287 CreateCommitError(#[from] CreateCommitError),
288 #[error(transparent)]
290 CommitBuilderStageError(#[from] CommitBuilderStageError<StorageError>),
291 #[error(transparent)]
293 GroupStateError(#[from] MlsGroupStateError),
294 #[error("Error writing to storage: {0}")]
296 StorageError(StorageError),
297}
298
299#[derive(Error, Debug, PartialEq, Clone)]
301pub enum ExportGroupInfoError {
302 #[error(transparent)]
304 LibraryError(#[from] LibraryError),
305 #[error(transparent)]
307 GroupStateError(#[from] MlsGroupStateError),
308}
309
310#[derive(Error, Debug, PartialEq, Clone)]
312pub enum ExportSecretError {
313 #[error(transparent)]
315 LibraryError(#[from] LibraryError),
316 #[error("The requested key length is too long.")]
318 KeyLengthTooLong,
319 #[error(transparent)]
321 GroupStateError(#[from] MlsGroupStateError),
322}
323
324#[derive(Error, Debug, PartialEq, Clone)]
326pub enum ProposePskError {
327 #[error(transparent)]
329 Psk(#[from] PskError),
330 #[error(transparent)]
332 GroupStateError(#[from] MlsGroupStateError),
333 #[error(transparent)]
335 LibraryError(#[from] LibraryError),
336}
337
338#[derive(Error, Debug, PartialEq, Clone)]
340pub enum ProposalError<StorageError> {
341 #[error(transparent)]
343 LibraryError(#[from] LibraryError),
344 #[error(transparent)]
346 ProposeAddMemberError(#[from] ProposeAddMemberError<StorageError>),
347 #[error(transparent)]
349 CreateAddProposalError(#[from] CreateAddProposalError),
350 #[error(transparent)]
352 ProposeSelfUpdateError(#[from] ProposeSelfUpdateError<StorageError>),
353 #[error(transparent)]
355 ProposeRemoveMemberError(#[from] ProposeRemoveMemberError<StorageError>),
356 #[error(transparent)]
358 GroupStateError(#[from] MlsGroupStateError),
359 #[error(transparent)]
361 ValidationError(#[from] ValidationError),
362 #[error(transparent)]
364 CreateGroupContextExtProposalError(#[from] CreateGroupContextExtProposalError<StorageError>),
365 #[error("error writing proposal to storage")]
367 StorageError(StorageError),
368}
369
370#[derive(Error, Debug, PartialEq, Clone)]
372pub enum RemoveProposalError<StorageError> {
373 #[error("Couldn't find the proposal for the given `ProposalRef`")]
375 ProposalNotFound,
376 #[error("error writing proposal to storage")]
378 Storage(StorageError),
379}