feat: Synchronize encrypted groups creation across devices (#7001)

Unencrypted groups don't have grpid since key-contacts were merged, so we don't sync them for now.

Author: iequidoo

deltachat-ffi/src/lib.rs

@@ -1676,7 +1676,7 @@ pub unsafe extern "C" fn dc_create_group_chat(
     };
 
     block_on(async move {
-        chat::create_group_chat(ctx, protect, &to_string_lossy(name))
+        chat::create_group(ctx, Some(protect), &to_string_lossy(name))
             .await
             .context("Failed to create group chat")
             .log_err(ctx)

deltachat-jsonrpc/src/api.rs

@@ -977,7 +977,7 @@ impl CommandApi {
             true => ProtectionStatus::Protected,
             false => ProtectionStatus::Unprotected,
         };
-        chat::create_group_ex(&ctx, Some(protect), &name)
+        chat::create_group(&ctx, Some(protect), &name)
             .await
             .map(|id| id.to_u32())
     }
@@ -988,7 +988,7 @@ impl CommandApi {
     /// address-contacts.
     async fn create_group_chat_unencrypted(&self, account_id: u32, name: String) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
-        chat::create_group_ex(&ctx, None, &name)
+        chat::create_group(&ctx, None, &name)
             .await
             .map(|id| id.to_u32())
     }

src/chat.rs

@@ -3657,30 +3657,45 @@ pub async fn get_past_chat_contacts(context: &Context, chat_id: ChatId) -> Resul
 }
 
 /// Creates a group chat with a given `name`.
-/// Deprecated on 2025-06-21, use `create_group_ex()`.
+/// Deprecated on 2025-06-21, use `create_group()`.
 pub async fn create_group_chat(
     context: &Context,
     protect: ProtectionStatus,
     name: &str,
 ) -> Result<ChatId> {
-    create_group_ex(context, Some(protect), name).await
+    create_group(context, Some(protect), name).await
 }
 
 /// Creates a group chat.
 ///
 /// * `encryption` - If `Some`, the chat is encrypted (with key-contacts) and can be protected.
 /// * `name` - Chat name.
-pub async fn create_group_ex(
+pub async fn create_group(
     context: &Context,
     encryption: Option<ProtectionStatus>,
     name: &str,
+) -> Result<ChatId> {
+    create_group_ex(context, Sync, encryption.map(|p| (create_id(), p)), name).await
+}
+
+/// Creates a group chat.
+///
+/// * `sync` - Whether a multi-device synchronization message should be sent. Ignored for
+///   unencrypted chats currently.
+///
+/// See [`create_group`] for other parameters.
+pub(crate) async fn create_group_ex(
+    context: &Context,
+    sync: sync::Sync,
+    encryption: Option<(String /* grpid */, ProtectionStatus)>,
+    name: &str,
 ) -> Result<ChatId> {
     let chat_name = sanitize_single_line(name);
     ensure!(!chat_name.is_empty(), "Invalid chat name");
 
-    let grpid = match encryption {
-        Some(_) => create_id(),
-        None => String::new(),
+    let (grpid, protection) = match encryption {
+        Some((grpid, protection)) => (grpid, Some(protection)),
+        None => (String::new(), None),
     };
 
     let timestamp = create_smeared_timestamp(context);
@@ -3690,7 +3705,7 @@ pub async fn create_group_ex(
             "INSERT INTO chats
         (type, name, grpid, param, created_timestamp)
         VALUES(?, ?, ?, \'U=1\', ?);",
-            (Chattype::Group, chat_name, grpid, timestamp),
+            (Chattype::Group, &chat_name, &grpid, timestamp),
         )
         .await?;
 
@@ -3701,7 +3716,7 @@ pub async fn create_group_ex(
     chatlist_events::emit_chatlist_changed(context);
     chatlist_events::emit_chatlist_item_changed(context, chat_id);
 
-    if encryption == Some(ProtectionStatus::Protected) {
+    if protection == Some(ProtectionStatus::Protected) {
         let protect = ProtectionStatus::Protected;
         chat_id
             .set_protection_for_timestamp_sort(context, protect, timestamp, None)
@@ -3714,7 +3729,11 @@ pub async fn create_group_ex(
         let text = stock_str::new_group_send_first_message(context).await;
         add_info_msg(context, chat_id, &text, create_smeared_timestamp(context)).await?;
     }
-
+    if let (true, Some(protection)) = (sync.into(), protection) {
+        let id = SyncId::Grpid(grpid);
+        let action = SyncAction::CreateGroupEncrypted(protection, chat_name);
+        self::sync(context, id, action).await.log_err(context).ok();
+    }
     Ok(chat_id)
 }
 
@@ -4985,7 +5004,7 @@ pub(crate) enum SyncId {
     /// "Message-ID"-s, from oldest to latest. Used for ad-hoc groups.
     Msgids(Vec<String>),
 
-    // Special id for device chat.
+    /// Special id for device chat.
     Device,
 }
 
@@ -4999,6 +5018,8 @@ pub(crate) enum SyncAction {
     SetMuted(MuteDuration),
     /// Create broadcast channel with the given name.
     CreateBroadcast(String),
+    /// Create encrypted group chat with the given name.
+    CreateGroupEncrypted(ProtectionStatus, String),
     Rename(String),
     /// Set chat contacts by their addresses.
     SetContacts(Vec<String>),
@@ -5064,6 +5085,9 @@ impl Context {
                 if let SyncAction::CreateBroadcast(name) = action {
                     create_broadcast_ex(self, Nosync, grpid.clone(), name.clone()).await?;
                     return Ok(());
+                } else if let SyncAction::CreateGroupEncrypted(protection, name) = action {
+                    create_group_ex(self, Nosync, Some((grpid.clone(), *protection)), name).await?;
+                    return Ok(());
                 }
                 get_chat_id_by_grpid(self, grpid)
                     .await?
@@ -5085,7 +5109,7 @@ impl Context {
             SyncAction::Accept => chat_id.accept_ex(self, Nosync).await,
             SyncAction::SetVisibility(v) => chat_id.set_visibility_ex(self, Nosync, *v).await,
             SyncAction::SetMuted(duration) => set_muted_ex(self, Nosync, chat_id, *duration).await,
-            SyncAction::CreateBroadcast(_) => {
+            SyncAction::CreateBroadcast(_) | SyncAction::CreateGroupEncrypted(..) => {
                 Err(anyhow!("sync_alter_chat({id:?}, {action:?}): Bad request."))
             }
             SyncAction::Rename(to) => rename_ex(self, Nosync, chat_id, to).await,

src/chat/chat_tests.rs

@@ -3800,6 +3800,30 @@ async fn test_sync_name() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_sync_create_group() -> Result<()> {
+    let mut tcm = TestContextManager::new();
+    let alice0 = &tcm.alice().await;
+    let alice1 = &tcm.alice().await;
+    for a in [alice0, alice1] {
+        a.set_config_bool(Config::SyncMsgs, true).await?;
+    }
+    for protection in [ProtectionStatus::Unprotected, ProtectionStatus::Protected] {
+        let a0_chat_id = create_group(alice0, Some(protection), "grp").await?;
+        sync(alice0, alice1).await;
+        let a0_chat = Chat::load_from_db(alice0, a0_chat_id).await?;
+        let a1_chat_id = get_chat_id_by_grpid(alice1, &a0_chat.grpid)
+            .await?
+            .unwrap()
+            .0;
+        let a1_chat = Chat::load_from_db(alice1, a1_chat_id).await?;
+        assert_eq!(a1_chat.get_type(), Chattype::Group);
+        assert_eq!(a1_chat.protected, protection);
+        assert_eq!(a1_chat.get_name(), "grp");
+    }
+    Ok(())
+}
+
 /// Tests sending JPEG image with .png extension.
 ///
 /// This is a regression test, previously sending failed
@@ -4707,7 +4731,7 @@ async fn test_create_unencrypted_group_chat() -> Result<()> {
     let bob = &tcm.bob().await;
     let charlie = &tcm.charlie().await;
 
-    let chat_id = create_group_ex(alice, None, "Group chat").await?;
+    let chat_id = create_group(alice, None, "Group chat").await?;
     let bob_key_contact_id = alice.add_or_lookup_contact_id(bob).await;
     let charlie_address_contact_id = alice.add_or_lookup_address_contact_id(charlie).await;