mls: remove group_id arg from NostrMls::process_message

Author: erskingardner

crates/nostr-mls/examples/mls_memory.rs

@@ -121,6 +121,35 @@ async fn main() -> Result<()> {
 
     tracing::info!("Bob joined group");
 
+    assert_eq!(
+        bob_nostr_mls
+            .get_groups()
+            .unwrap()
+            .first()
+            .unwrap()
+            .nostr_group_id,
+        alice_group.nostr_group_id,
+        "Bob's group should have the same Nostr group ID as Alice's group"
+    );
+
+    assert_eq!(
+        hex::encode(
+            bob_nostr_mls
+                .get_groups()
+                .unwrap()
+                .first()
+                .unwrap()
+                .nostr_group_id
+        ),
+        message_event
+            .tags
+            .iter()
+            .find(|tag| tag.kind() == TagKind::h())
+            .unwrap()
+            .content()
+            .unwrap(),
+        "Bob's group should have the same Nostr group ID as Alice's message wrapper event"
+    );
     // Bob and Alice now have synced state for the group.
     assert_eq!(
         bob_nostr_mls.get_members(&bob_mls_group_id).unwrap().len(),
@@ -139,9 +168,13 @@ async fn main() -> Result<()> {
 
     // The resulting serialized message is the MLS encrypted message that Bob sent
     // Now Bob can process the MLS message content and do what's needed with it
-    bob_nostr_mls.process_message(&bob_mls_group_id, &message_event)?;
+    bob_nostr_mls.process_message(&message_event)?;
 
-    let messages = bob_nostr_mls.get_messages(&bob_mls_group_id).unwrap();
+    tracing::info!("Bob processed message");
+    let messages = bob_nostr_mls
+        .get_messages(&bob_mls_group_id)
+        .map_err(|e| crate::error::Error::Message(e.to_string()))?;
+    tracing::info!("Bob got messages: {:?}", messages);
     let message = messages.first().unwrap();
     tracing::info!("Bob processed message: {:?}", message);
 
@@ -188,10 +221,7 @@ async fn main() -> Result<()> {
     );
 
     tracing::info!("Alice about to process message");
-    alice_nostr_mls.process_message(
-        &GroupId::from_slice(alice_group.mls_group_id.as_slice()),
-        &message_event,
-    )?;
+    alice_nostr_mls.process_message(&message_event)?;
 
     let messages = alice_nostr_mls
         .get_messages(&GroupId::from_slice(alice_group.mls_group_id.as_slice()))

crates/nostr-mls/examples/mls_sqlite.rs

@@ -145,7 +145,7 @@ async fn main() -> Result<()> {
 
     // The resulting serialized message is the MLS encrypted message that Bob sent
     // Now Bob can process the MLS message content and do what's needed with it
-    bob_nostr_mls.process_message(&bob_mls_group_id, &message_event)?;
+    bob_nostr_mls.process_message(&message_event)?;
 
     let messages = bob_nostr_mls.get_messages(&bob_mls_group_id).unwrap();
     let message = messages.first().unwrap();
@@ -197,10 +197,7 @@ async fn main() -> Result<()> {
     );
 
     tracing::info!("Alice about to process message");
-    alice_nostr_mls.process_message(
-        &GroupId::from_slice(alice_group.mls_group_id.as_slice()),
-        &message_event,
-    )?;
+    alice_nostr_mls.process_message(&message_event)?;
 
     let messages = alice_nostr_mls
         .get_messages(&GroupId::from_slice(alice_group.mls_group_id.as_slice()))

crates/nostr-mls/src/messages.rs

@@ -300,22 +300,38 @@ where
     ///
     /// * `Ok(())` - If message processing succeeds
     /// * `Err(Error)` - If message processing fails
-    pub fn process_message(&self, mls_group_id: &GroupId, event: &Event) -> Result<(), Error> {
+    pub fn process_message(&self, event: &Event) -> Result<(), Error> {
         if event.kind != Kind::MlsGroupMessage {
             return Err(Error::UnexpectedEvent {
                 expected: Kind::MlsGroupMessage,
                 received: event.kind,
             });
         }
 
-        // Load group
-        let mut mls_group = self
-            .load_mls_group(mls_group_id)?
+        let nostr_group_id_tag = event
+            .tags
+            .iter()
+            .find(|tag| tag.kind() == TagKind::h())
+            .ok_or(Error::Message("Group ID Tag not found".to_string()))?;
+
+        let nostr_group_id: [u8; 32] = hex::decode(
+            nostr_group_id_tag
+                .content()
+                .ok_or(Error::Message("Group ID Tag content not found".to_string()))?,
+        )
+        .map_err(|e| Error::Message(e.to_string()))?
+        .try_into()
+        .map_err(|_e| Error::Message("Failed to convert nostr group id to [u8; 32]".to_string()))?;
+
+        let group = self
+            .storage()
+            .find_group_by_nostr_group_id(&nostr_group_id)
+            .map_err(|e| Error::Group(e.to_string()))?
             .ok_or(Error::GroupNotFound)?;
 
         // Load group exporter secret
         let secret: group_types::GroupExporterSecret = self
-            .exporter_secret(mls_group_id)
+            .exporter_secret(&group.mls_group_id)
             .map_err(|e| Error::Group(e.to_string()))?;
 
         // Convert that secret to nostr keys
@@ -329,6 +345,11 @@ where
             &event.content,
         )?;
 
+        let mut mls_group = self
+            .load_mls_group(&group.mls_group_id)
+            .map_err(|e| Error::Group(e.to_string()))?
+            .ok_or(Error::GroupNotFound)?;
+
         // The resulting serialized message is the MLS encrypted message that Bob sent
         // Now Bob can process the MLS message content and do what's needed with it
         match self.process_message_for_group(&mut mls_group, &message_bytes) {
@@ -345,7 +366,7 @@ where
                     id: rumor.id.unwrap(),
                     pubkey: rumor.pubkey,
                     kind: rumor.kind,
-                    mls_group_id: mls_group_id.clone(),
+                    mls_group_id: group.mls_group_id.clone(),
                     created_at: rumor.created_at,
                     content: rumor.content.clone(),
                     tags: rumor.tags.clone(),
@@ -355,13 +376,15 @@ where
                 };
 
                 self.storage()
-                    .save_message(message)
+                    .save_message(message.clone())
                     .map_err(|e| Error::Message(e.to_string()))?;
 
                 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", "Processed message: {:?}", processed_message);
+                tracing::debug!(target: "nostr_mls::messages::process_message", "Message: {:?}", message);
                 Ok(())
             }
             Ok(None) => {