mls: return values for welcomes and messages on processing

Author: erskingardner

crates/nostr-mls/src/error.rs

@@ -75,6 +75,8 @@ pub enum Error {
     SelfUpdate(String),
     /// Welcome error
     Welcome(String),
+    /// We're missing a Welcome for an existing ProcessedWelcome
+    MissingWelcomeForProcessedWelcome,
     /// Provider error
     Provider(String),
     /// Group not found
@@ -128,6 +130,9 @@ impl fmt::Display for Error {
             Self::Message(e) => write!(f, "{e}"),
             Self::CannotDecryptOwnMessage => write!(f, "cannot decrypt own message"),
             Self::Welcome(e) => write!(f, "{e}"),
+            Self::MissingWelcomeForProcessedWelcome => {
+                write!(f, "missing welcome for processed welcome")
+            }
             Self::MergePendingCommit(e) => write!(f, "{e}"),
             Self::SelfUpdate(e) => write!(f, "{e}"),
             Self::Provider(e) => write!(f, "{e}"),

crates/nostr-mls/src/messages.rs

@@ -300,7 +300,7 @@ where
     ///
     /// * `Ok(())` - If message processing succeeds
     /// * `Err(Error)` - If message processing fails
-    pub fn process_message(&self, event: &Event) -> Result<(), Error> {
+    pub fn process_message(&self, event: &Event) -> Result<Option<message_types::Message>, Error> {
         if event.kind != Kind::MlsGroupMessage {
             return Err(Error::UnexpectedEvent {
                 expected: Kind::MlsGroupMessage,
@@ -385,7 +385,7 @@ where
 
                 tracing::debug!(target: "nostr_mls::messages::process_message", "Processed message: {:?}", processed_message);
                 tracing::debug!(target: "nostr_mls::messages::process_message", "Message: {:?}", message);
-                Ok(())
+                Ok(Some(message))
             }
             Ok(None) => {
                 // This is what happens with proposals, commits, etc.
@@ -401,7 +401,7 @@ where
                     .save_processed_message(processed_message)
                     .map_err(|e| Error::Message(e.to_string()))?;
 
-                Ok(())
+                Ok(None)
             }
             Err(e) => {
                 match e {
@@ -429,7 +429,7 @@ where
                                 processed_message.state =
                                     message_types::ProcessedMessageState::Processed;
                                 self.storage()
-                                    .save_processed_message(processed_message)
+                                    .save_processed_message(processed_message.clone())
                                     .map_err(|e| Error::Message(e.to_string()))?;
 
                                 tracing::debug!(target: "nostr_mls::messages::process_message", "Updated state of own cached message");
@@ -441,7 +441,9 @@ where
                                 tracing::debug!(target: "nostr_mls::messages::process_message", "Message previously failed to process");
                             }
                         }
-                        return Ok(());
+                        let message =
+                            self.get_message(&processed_message.message_event_id.unwrap())?;
+                        return Ok(message);
                     }
                     _ => {
                         tracing::error!(target: "nostr_mls::messages::process_message", "Error processing message: {:?}", e);
@@ -457,7 +459,7 @@ where
                             .map_err(|e| Error::Message(e.to_string()))?;
                     }
                 }
-                Ok(())
+                Ok(None)
             }
         }
     }

crates/nostr-mls/src/welcomes.rs

@@ -58,9 +58,25 @@ where
         &self,
         wrapper_event_id: &EventId,
         rumor_event: &UnsignedEvent,
-    ) -> Result<(), Error> {
+    ) -> Result<welcome_types::Welcome, Error> {
         if self.is_welcome_processed(wrapper_event_id)? {
-            return Ok(());
+            let processed_welcome = self
+                .storage()
+                .find_processed_welcome_by_event_id(wrapper_event_id)
+                .map_err(|e| Error::Welcome(e.to_string()))?;
+            return match processed_welcome {
+                Some(processed_welcome) => {
+                    if let Some(welcome_event_id) = processed_welcome.welcome_event_id {
+                        self.storage()
+                            .find_welcome_by_event_id(&welcome_event_id)
+                            .map_err(|e| Error::Welcome(e.to_string()))?
+                            .ok_or(Error::MissingWelcomeForProcessedWelcome)
+                    } else {
+                        Err(Error::MissingWelcomeForProcessedWelcome)
+                    }
+                }
+                None => Err(Error::MissingWelcomeForProcessedWelcome),
+            };
         }
 
         let welcome_preview = self.preview_welcome(wrapper_event_id, rumor_event)?;
@@ -128,10 +144,10 @@ where
             .map_err(|e| Error::Welcome(e.to_string()))?;
 
         self.storage()
-            .save_welcome(welcome)
+            .save_welcome(welcome.clone())
             .map_err(|e| Error::Welcome(e.to_string()))?;
 
-        Ok(())
+        Ok(welcome)
     }
 
     /// Accepts a welcome